diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
new file mode 100644
index 0000000..df0f886
--- /dev/null
+++ b/.github/workflows/codspeed.yml
@@ -0,0 +1,83 @@
+name: CodSpeed
+
+on:
+  push:
+    branches:
+      - "main"
+      - "master"
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  benchmarks:
+    name: Run benchmarks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Start infrastructure
+        run: |
+          docker compose -f docker-compose-test.yml up -d
+
+      - name: Wait for MySQL
+        run: |
+          for i in $(seq 1 30); do
+            if docker compose -f docker-compose-test.yml exec -T mysql_tests mysqladmin ping -h localhost -ucqrs -pcqrs --silent 2>/dev/null; then
+              echo "MySQL is ready"
+              exit 0
+            fi
+            echo "Waiting for MySQL... ($i/30)"
+            sleep 2
+          done
+          echo "MySQL did not become ready in time"
+          exit 1
+
+      - name: Wait for PostgreSQL
+        run: |
+          for i in $(seq 1 30); do
+            if docker compose -f docker-compose-test.yml exec -T postgres_tests pg_isready -h localhost -U cqrs -q 2>/dev/null; then
+              echo "PostgreSQL is ready"
+              exit 0
+            fi
+            echo "Waiting for PostgreSQL... ($i/30)"
+            sleep 2
+          done
+          echo "PostgreSQL did not become ready in time"
+          exit 1
+
+      - name: Wait for Redis
+        run: |
+          for i in $(seq 1 15); do
+            if docker compose -f docker-compose-test.yml exec -T redis_tests redis-cli ping 2>/dev/null | grep -q PONG; then
+              echo "Redis is ready"
+              exit 0
+            fi
+            echo "Waiting for Redis... ($i/15)"
+            sleep 1
+          done
+          echo "Redis did not become ready in time"
+          exit 1
+
+      - name: Run benchmarks
+        uses: CodSpeedHQ/action@v4
+        with:
+          mode: simulation
+          run: pytest -c ./tests/pytest-config.ini tests/benchmarks/ --codspeed
+
+      - name: Stop infrastructure
+        if: always()
+        run: docker compose -f docker-compose-test.yml down -v
diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml
index fe4f678..e34785b 100644
--- a/.github/workflows/python-publish.yml
+++ b/.github/workflows/python-publish.yml
@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [ "3.12" ]
+        python-version: [ "3.10", "3.11", "3.12" ]
 
     steps:
       - uses: actions/checkout@v4
@@ -28,6 +28,6 @@ jobs:
       - name: Build package
         run: python -m build
       - name: Publish package
-        if: success() && github.event_name == 'release'
+        if: success() && github.event_name == 'release' && matrix.python-version == '3.12'
         run: |
           twine upload dist/* --username __token__ --password ${{ secrets.PYPI_API_TOKEN }}
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..3f69bfc
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,151 @@
+name: Tests
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e ".[dev,examples]"
+
+    - name: Get changed Python files
+      id: changed
+      run: |
+        git fetch origin main master 2>/dev/null || true
+        BASE="origin/main"
+        if ! git rev-parse --verify origin/main >/dev/null 2>&1; then BASE="origin/master"; fi
+        git diff --name-only $BASE...HEAD -- src/ tests/ examples/ | grep -E '\.py$' > changed.txt || true
+        if [ -s changed.txt ]; then
+          echo "has_changes=true" >> $GITHUB_OUTPUT
+        else
+          echo "has_changes=false" >> $GITHUB_OUTPUT
+        fi
+        echo "Changed files:"
+        cat changed.txt || true
+
+    - name: Run ruff check
+      run: |
+        if [ "${{ steps.changed.outputs.has_changes }}" != "true" ]; then
+          echo "No Python files changed, skipping ruff check"
+          exit 0
+        fi
+        while IFS= read -r f; do [ -f "$f" ] && echo "$f"; done < changed.txt | xargs -r ruff check --config ruff.toml
+
+    - name: Run ruff format check
+      run: |
+        if [ "${{ steps.changed.outputs.has_changes }}" != "true" ]; then
+          echo "No Python files changed, skipping ruff format"
+          exit 0
+        fi
+        while IFS= read -r f; do [ -f "$f" ] && echo "$f"; done < changed.txt | xargs -r ruff format --check --config ruff.toml
+
+    - name: Run pyright
+      run: |
+        pyright --pythonversion ${{ matrix.python-version }} src tests examples
+
+    - name: Check minimum Python version (vermin)
+      run: |
+        vermin --target=3.10- --violations --eval-annotations --backport typing_extensions --exclude=venv --exclude=build --exclude=.git --exclude=.venv src examples tests
+
+  test:
+    name: test (py ${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -e ".[dev]"
+
+    - name: Start infrastructure
+      run: |
+        docker compose -f docker-compose-test.yml up -d
+
+    - name: Wait for MySQL
+      run: |
+        for i in $(seq 1 30); do
+          if docker compose -f docker-compose-test.yml exec -T mysql_tests mysqladmin ping -h localhost -ucqrs -pcqrs --silent 2>/dev/null; then
+            echo "MySQL is ready"
+            exit 0
+          fi
+          echo "Waiting for MySQL... ($i/30)"
+          sleep 2
+        done
+        echo "MySQL did not become ready in time"
+        exit 1
+
+    - name: Wait for PostgreSQL
+      run: |
+        for i in $(seq 1 30); do
+          if docker compose -f docker-compose-test.yml exec -T postgres_tests pg_isready -h localhost -U cqrs -q 2>/dev/null; then
+            echo "PostgreSQL is ready"
+            exit 0
+          fi
+          echo "Waiting for PostgreSQL... ($i/30)"
+          sleep 2
+        done
+        echo "PostgreSQL did not become ready in time"
+        exit 1
+
+    - name: Wait for Redis
+      run: |
+        for i in $(seq 1 15); do
+          if docker compose -f docker-compose-test.yml exec -T redis_tests redis-cli ping 2>/dev/null | grep -q PONG; then
+            echo "Redis is ready"
+            exit 0
+          fi
+          echo "Waiting for Redis... ($i/15)"
+          sleep 1
+        done
+        echo "Redis did not become ready in time"
+        exit 1
+
+    - name: Run all tests with coverage
+      env:
+        DATABASE_DSN: mysql+asyncmy://cqrs:cqrs@localhost:3307/test_cqrs
+        DATABASE_DSN_MYSQL: mysql+asyncmy://cqrs:cqrs@localhost:3307/test_cqrs
+        DATABASE_DSN_POSTGRESQL: postgresql+asyncpg://cqrs:cqrs@localhost:5433/cqrs
+      run: |
+        pytest -c ./tests/pytest-config.ini --cov=src --cov-report=xml --cov-report=term -o cache_dir=/tmp/pytest_cache ./tests/unit ./tests/integration
+
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v4
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        fail_ci_if_error: false
+
+    - name: Stop infrastructure
+      if: always()
+      run: docker compose -f docker-compose-test.yml down -v
diff --git a/.gitignore b/.gitignore
index 5b07807..34a7e62 100644
--- a/.gitignore
+++ b/.gitignore
@@ -167,3 +167,5 @@ tmp/
 
 # UV lock
 uv.lock
+
+.codspeed/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 3e85db2..67e2f15 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,17 +1,15 @@
 repos:
 - hooks:
-  - id: check-toml
   - id: check-docstring-first
   - id: check-ast
-  - exclude: (^tests/mock/|^tests/integration/|^tests/fixtures)
+  - exclude: (^tests/mock/|^tests/integration/|^tests/fixtures|benchmarks)
     id: trailing-whitespace
   - id: end-of-file-fixer
   - id: check-yaml
-  - id: check-toml
   - id: check-added-large-files
   - args:
     - --pytest-test-first
-    exclude: (^tests/mock/|^tests/integration/|^tests/fixtures)
+    exclude: (^tests/mock/|^tests/integration/|^tests/fixtures|conftest\.py$)
     id: name-tests-test
   - id: check-merge-conflict
   - id: check-json
@@ -21,25 +19,6 @@ repos:
   - id: add-trailing-comma
   repo: https://github.com/asottile/add-trailing-comma
   rev: v3.1.0
-- hooks:
-  - args:
-    - --autofix
-    - --indent
-    - '2'
-    files: ^.*\.yaml$
-    id: pretty-format-yaml
-  - args:
-    - --autofix
-    - --indent
-    - '2'
-    id: pretty-format-toml
-  repo: https://github.com/macisamuele/language-formatters-pre-commit-hooks
-  rev: v2.12.0
-- hooks:
-  - id: toml-sort
-  - id: toml-sort-fix
-  repo: https://github.com/pappasam/toml-sort
-  rev: v0.23.1
 - hooks:
   - id: pycln
     name: pycln
@@ -52,15 +31,24 @@ repos:
   rev: v1.0.1
 - hooks:
   - id: ruff
-    args: [--fix]
+    args: [--fix, --config, ruff.toml]
   - id: ruff-format
+    args: [--config, ruff.toml]
   repo: https://github.com/astral-sh/ruff-pre-commit
   rev: v0.6.1
 - repo: https://github.com/RobertCraigie/pyright-python
   rev: v1.1.380
   hooks:
   - id: pyright
+    args: [--project, .]
     types: [python]
+- repo: https://github.com/netromdk/vermin
+  rev: v1.6.0
+  hooks:
+  - id: vermin
+    args: [--target=3.10-, --violations, --eval-annotations, --backport typing_extensions, --exclude=venv, --exclude=build, --exclude=.git, --exclude=.venv, src, examples, tests]
+    language: python
+    additional_dependencies: [vermin]
 - repo: local
   hooks:
   - id: pytest-unit
diff --git a/README.md b/README.md
index e5664b6..67d71d2 100644
--- a/README.md
+++ b/README.md
@@ -1,15 +1,34 @@
 <div align="center">
+  <img
+    src="https://raw.githubusercontent.com/vadikko2/python-cqrs-mkdocs/master/docs/img.png"
+    alt="Python CQRS"
+    style="max-width: 80%;"
+  >
   <h1>Python CQRS</h1>
-  <p>Event-Driven Architecture Framework for Distributed Systems</p>
-
+  <p><strong>Event-Driven Architecture Framework for Distributed Systems</strong></p>
+  <p>
+    <strong>Python 3.10+</strong> · Full documentation: <a href="https://mkdocs.python-cqrs.dev/">mkdocs.python-cqrs.dev</a>
+  </p>
   <p>
     <a href="https://pypi.org/project/python-cqrs/">
-      <img src="https://img.shields.io/pypi/v/python-cqrs?label=pypi&logo=pypi" alt="PyPI version">
+      <img src="https://img.shields.io/pypi/pyversions/python-cqrs?logo=python&logoColor=white" alt="Python Versions">
     </a>
     <a href="https://pypi.org/project/python-cqrs/">
-      <img src="https://img.shields.io/pypi/dm/python-cqrs?label=downloads&logo=pypi" alt="PyPI downloads">
+      <img src="https://img.shields.io/pypi/v/python-cqrs?label=pypi&logo=pypi" alt="PyPI version">
+    </a>
+    <a href="https://pepy.tech/projects/python-cqrs">
+      <img src="https://pepy.tech/badge/python-cqrs" alt="Total downloads">
+    </a>
+    <a href="https://pepy.tech/projects/python-cqrs">
+      <img src="https://pepy.tech/badge/python-cqrs/month" alt="Downloads per month">
     </a>
-    <a href="https://vadikko2.github.io/python-cqrs-mkdocs/">
+    <a href="https://codecov.io/gh/vadikko2/python-cqrs">
+      <img src="https://img.shields.io/codecov/c/github/vadikko2/python-cqrs?logo=codecov&logoColor=white" alt="Coverage">
+    </a>
+    <a href="https://codspeed.io/vadikko2/python-cqrs?utm_source=badge">
+      <img src="https://img.shields.io/endpoint?url=https://codspeed.io/badge.json" alt="CodSpeed">
+    </a>
+    <a href="https://mkdocs.python-cqrs.dev/">
       <img src="https://img.shields.io/badge/docs-mkdocs-blue?logo=readthedocs" alt="Documentation">
     </a>
     <a href="https://deepwiki.com/vadikko2/python-cqrs">
@@ -18,38 +37,157 @@
   </p>
 </div>
 
-<div align="center">
-  <img
-    src="https://raw.githubusercontent.com/vadikko2/python-cqrs-mkdocs/master/docs/img.png"
-    alt="Python CQRS"
-    style="max-width: 80%; width: 800px; border-radius: 16px; box-shadow: 0 8px 32px rgba(0, 102, 204, 0.2); display: block; margin: 2rem auto;"
-  >
-</div>
+> [!WARNING]
+> **Breaking Changes in v5.0.0**
+>
+> Starting with version 5.0.0, Pydantic support will become optional. The default implementations of `Request`, `Response`, `DomainEvent`, and `NotificationEvent` will be migrated to dataclasses-based implementations.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Request and Response Types](#request-and-response-types)
+- [Request Handlers](#request-handlers)
+- [Mapping](#mapping)
+- [DI container](#di-container)
+- [Bootstrap](#bootstrap)
+- [Saga Pattern](#saga-pattern)
+- [Producing Notification Events](#producing-notification-events)
+- [Kafka broker](#kafka-broker)
+- [Transactional Outbox](#transactional-outbox)
+- [Producing Events from Outbox to Kafka](#producing-events-from-outbox-to-kafka)
+- [Transaction log tailing](#transaction-log-tailing)
+- [Event Handlers](#event-handlers)
+- [Integration with presentation layers](#integration-with-presentation-layers)
+- [Protobuf messaging](#protobuf-messaging)
+- [Contributing](#contributing)
+- [Changelog](#changelog)
+- [License](#license)
 
 ## Overview
 
-This is a package for implementing the CQRS (Command Query Responsibility Segregation) pattern in Python applications.
-It provides a set of abstractions and utilities to help separate read and write use cases, ensuring better scalability,
-performance, and maintainability of the application.
+An event-driven framework for building distributed systems in Python. It centers on CQRS (Command Query Responsibility Segregation) and extends into messaging, sagas, and reliable event delivery — so you can separate read and write flows, react to events from the bus, run distributed transactions with compensation, and publish events via Transaction Outbox. The result is clearer structure, better scalability, and easier evolution of the application.
 
 This package is a fork of the [diator](https://github.com/akhundMurad/diator)
-project ([documentation](https://akhundmurad.github.io/diator/)) with several enhancements:
-
-1. Support for Pydantic [v2.*](https://docs.pydantic.dev/2.8/);
-2. `Kafka` support using [aiokafka](https://github.com/aio-libs/aiokafka);
-3. Added `EventMediator` for handling `Notification` and `ECST` events coming from the bus;
-4. Redesigned the event and request mapping mechanism to handlers;
-5. Added `bootstrap` for easy setup;
-6. Added support for [Transaction Outbox](https://microservices.io/patterns/data/transactional-outbox.html), ensuring
-   that `Notification` and `ECST` events are sent to the broker;
-7. FastAPI supporting;
-8. FastStream supporting;
-9. [Protobuf](https://protobuf.dev/) events supporting;
-10. `StreamingRequestMediator` and `StreamingRequestHandler` for handling streaming requests with real-time progress updates;
-11. Parallel event processing with configurable concurrency limits;
-12. Chain of Responsibility pattern support with `CORRequestHandler` for processing requests through multiple handlers in sequence;
-13. Orchestrated Saga pattern support for managing distributed transactions with automatic compensation and recovery mechanisms;
-14. Built-in Mermaid diagram generation, enabling automatic generation of Sequence and Class diagrams for documentation and visualization.
+project ([documentation](https://akhundmurad.github.io/diator/)) with several enhancements, ordered by importance:
+
+**Core framework**
+
+1. Redesigned the event and request mapping mechanism to handlers;
+2. `EventMediator` for handling `Notification` and `ECST` events coming from the bus;
+3. `bootstrap` for easy setup;
+4. **Transaction Outbox**, ensuring that `Notification` and `ECST` events are sent to the broker;
+5. **Orchestrated Saga** pattern for distributed transactions with automatic compensation and recovery;
+6. `StreamingRequestMediator` and `StreamingRequestHandler` for streaming requests with real-time progress updates;
+7. **Chain of Responsibility** with `CORRequestHandler` for processing requests through multiple handlers in sequence;
+8. **Parallel event processing** with configurable concurrency limits.
+
+**Also**
+
+- **Typing:** Pydantic [v2.*](https://docs.pydantic.dev/2.8/) and `IRequest`/`IResponse` interfaces — use Pydantic-based, dataclass-based, or custom Request/Response implementations.
+- **Broker:** Kafka via [aiokafka](https://github.com/aio-libs/aiokafka).
+- **Integration:** Ready for integration with FastAPI and FastStream.
+- **Documentation:** Built-in Mermaid diagram generation (Sequence and Class diagrams).
+- **Protobuf:** Interface-level support for converting Notification events to Protobuf and back.
+
+## Installation
+
+**Python 3.10+** is required.
+
+```bash
+pip install python-cqrs
+```
+
+Optional dependencies (see [pyproject.toml](https://github.com/vadikko2/python-cqrs/blob/master/pyproject.toml) for full list):
+
+```bash
+pip install python-cqrs[kafka]      # Kafka broker (aiokafka)
+pip install python-cqrs[examples]    # FastAPI, FastStream, uvicorn, etc.
+pip install python-cqrs[aiobreaker]  # Circuit breaker for saga fallbacks
+```
+
+## Quick Start
+
+Define a command, a handler, bind them, and run via the mediator:
+
+```python
+import di
+import cqrs
+from cqrs.requests import bootstrap
+
+class CreateOrderCommand(cqrs.Request):
+    order_id: str
+    amount: float
+
+class CreateOrderHandler(cqrs.RequestHandler[CreateOrderCommand, None]):
+    async def handle(self, request: CreateOrderCommand) -> None:
+        print(f"Order {request.order_id}, amount {request.amount}")
+
+def commands_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(CreateOrderCommand, CreateOrderHandler)
+
+container = di.Container()
+mediator = bootstrap.bootstrap(di_container=container, commands_mapper=commands_mapper)
+await mediator.send(CreateOrderCommand(order_id="ord-1", amount=99.99))
+```
+
+For full setup with DI, events, and outbox, see the [documentation](https://mkdocs.python-cqrs.dev/) and the [examples](https://github.com/vadikko2/python-cqrs/tree/master/examples) directory.
+
+## Request and Response Types
+
+The library supports both Pydantic-based (`PydanticRequest`/`PydanticResponse`, aliased as `Request`/`Response`) and Dataclass-based (`DCRequest`/`DCResponse`) implementations. You can also implement custom classes by implementing the `IRequest`/`IResponse` interfaces directly.
+
+```python
+import dataclasses
+
+# Pydantic-based (default)
+class CreateUserCommand(cqrs.Request):
+    username: str
+    email: str
+
+class UserResponse(cqrs.Response):
+    user_id: str
+    username: str
+
+# Dataclass-based
+@dataclasses.dataclass
+class CreateProductCommand(cqrs.DCRequest):
+    name: str
+    price: float
+
+@dataclasses.dataclass
+class ProductResponse(cqrs.DCResponse):
+    product_id: str
+    name: str
+
+# Custom implementation
+class CustomRequest(cqrs.IRequest):
+    def __init__(self, user_id: str, action: str):
+        self.user_id = user_id
+        self.action = action
+
+    def to_dict(self) -> dict:
+        return {"user_id": self.user_id, "action": self.action}
+
+    @classmethod
+    def from_dict(cls, **kwargs) -> "CustomRequest":
+        return cls(user_id=kwargs["user_id"], action=kwargs["action"])
+
+class CustomResponse(cqrs.IResponse):
+    def __init__(self, result: str, status: int):
+        self.result = result
+        self.status = status
+
+    def to_dict(self) -> dict:
+        return {"result": self.result, "status": self.status}
+
+    @classmethod
+    def from_dict(cls, **kwargs) -> "CustomResponse":
+        return cls(result=kwargs["result"], status=kwargs["status"])
+```
+
+A complete example can be found in [request_response_types.py](https://github.com/vadikko2/python-cqrs/blob/master/examples/request_response_types.py)
 
 ## Request Handlers
 
@@ -71,7 +209,7 @@ class JoinMeetingCommandHandler(RequestHandler[JoinMeetingCommand, None]):
 
       def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
           self._meetings_api = meetings_api
-          self.events: list[Event] = []
+          self._events: list[Event] = []
 
       @property
       def events(self) -> typing.List[events.Event]:
@@ -82,7 +220,7 @@ class JoinMeetingCommandHandler(RequestHandler[JoinMeetingCommand, None]):
 ```
 
 A complete example can be found in
-the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/request_handler.py)
+the [documentation](https://github.com/vadikko2/python-cqrs/blob/master/examples/request_handler.py)
 
 ### Query handler
 
@@ -99,7 +237,7 @@ class ReadMeetingQueryHandler(RequestHandler[ReadMeetingQuery, ReadMeetingQueryR
 
       def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
           self._meetings_api = meetings_api
-          self.events: list[Event] = []
+          self._events: list[Event] = []
 
       @property
       def events(self) -> typing.List[events.Event]:
@@ -112,7 +250,7 @@ class ReadMeetingQueryHandler(RequestHandler[ReadMeetingQuery, ReadMeetingQueryR
 ```
 
 A complete example can be found in
-the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/request_handler.py)
+the [documentation](https://github.com/vadikko2/python-cqrs/blob/master/examples/request_handler.py)
 
 ### Streaming Request Handler
 
@@ -148,7 +286,7 @@ class ProcessFilesCommandHandler(StreamingRequestHandler[ProcessFilesCommand, Fi
 ```
 
 A complete example can be found in
-the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/streaming_handler_parallel_events.py)
+the [documentation](https://github.com/vadikko2/python-cqrs/blob/master/examples/streaming_handler_parallel_events.py)
 
 ### Chain of Responsibility Request Handler
 
@@ -211,7 +349,7 @@ def payment_mapper(mapper: cqrs.RequestMap) -> None:
 ```
 
 A complete example can be found in
-the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/cor_request_handler.py)
+the [documentation](https://github.com/vadikko2/python-cqrs/blob/master/examples/cor_request_handler.py)
 
 #### Mermaid Diagram Generation
 
@@ -231,7 +369,169 @@ sequence_diagram = generator.sequence()
 class_diagram = generator.class_diagram()
 ```
 
-Complete example: [CoR Mermaid Diagrams](https://github.com/vadikko2/cqrs/blob/master/examples/cor_mermaid.py)
+Complete example: [CoR Mermaid Diagrams](https://github.com/vadikko2/python-cqrs/blob/master/examples/cor_mermaid.py)
+
+## Mapping
+
+To bind commands, queries and events with specific handlers, you can use the registries `EventMap`, `RequestMap`, and `SagaMap`.
+
+**Commands, queries and events:**
+
+```python
+from cqrs import requests, events
+
+from app import commands, command_handlers
+from app import queries, query_handlers
+from app import events as event_models, event_handlers
+
+
+def init_commands(mapper: requests.RequestMap) -> None:
+    mapper.bind(commands.JoinMeetingCommand, command_handlers.JoinMeetingCommandHandler)
+
+def init_queries(mapper: requests.RequestMap) -> None:
+    mapper.bind(queries.ReadMeetingQuery, query_handlers.ReadMeetingQueryHandler)
+
+def init_events(mapper: events.EventMap) -> None:
+    mapper.bind(events.NotificationEvent[event_models.NotificationMeetingRoomClosed], event_handlers.MeetingRoomClosedNotificationHandler)
+    mapper.bind(events.NotificationEvent[event_models.ECSTMeetingRoomClosed], event_handlers.UpdateMeetingRoomReadModelHandler)
+```
+
+**Chain of Responsibility** — bind a list of handlers (the first one that can handle the request processes it, otherwise the request is passed to the next):
+
+```python
+def payment_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(
+        ProcessPaymentCommand,
+        [
+            CreditCardPaymentHandler,
+            PayPalPaymentHandler,
+            DefaultPaymentHandler,  # Fallback
+        ],
+    )
+```
+
+**Streaming handler** — bind a command to a `StreamingRequestHandler` (results are yielded as they become available):
+
+```python
+def commands_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(ProcessOrdersCommand, ProcessOrdersCommandHandler)  # StreamingRequestHandler
+```
+
+**Saga (including with fallback)** — bind the saga context type to the saga class in `SagaMap`:
+
+```python
+def saga_mapper(mapper: cqrs.SagaMap) -> None:
+    mapper.bind(OrderContext, OrderSaga)
+    mapper.bind(OrderContext, OrderSagaWithFallback)
+```
+
+## DI container
+
+Use the following example to set up dependency injection in your command, query and event handlers. This will make
+dependency management simpler.
+
+The package supports two DI container libraries:
+
+### di library
+
+```python
+import di
+...
+
+def setup_di() -> di.Container:
+    """
+    Binds implementations to dependencies
+    """
+    container = di.Container()
+    container.bind(
+        di.bind_by_type(
+            dependent.Dependent(cqrs.SqlAlchemyOutboxedEventRepository, scope="request"),
+            cqrs.OutboxedEventRepository
+        )
+    )
+    container.bind(
+        di.bind_by_type(
+            dependent.Dependent(MeetingAPIImplementaion, scope="request"),
+            MeetingAPIProtocol
+        )
+    )
+    return container
+```
+
+A complete example can be found in
+the [documentation](https://github.com/vadikko2/python-cqrs/blob/master/examples/dependency_injection.py)
+
+### dependency-injector library
+
+The package also supports [dependency-injector](https://github.com/ets-labs/python-dependency-injector) library.
+You can use `DependencyInjectorCQRSContainer` adapter to integrate dependency-injector containers with python-cqrs.
+
+```python
+from dependency_injector import containers, providers
+from cqrs.container.dependency_injector import DependencyInjectorCQRSContainer
+
+class ApplicationContainer(containers.DeclarativeContainer):
+    # Define your providers
+    service = providers.Factory(ServiceImplementation)
+
+# Create CQRS container adapter
+cqrs_container = DependencyInjectorCQRSContainer(ApplicationContainer())
+
+# Use with bootstrap
+mediator = bootstrap.bootstrap(
+    di_container=cqrs_container,
+    commands_mapper=commands_mapper,
+    ...
+)
+```
+
+Complete examples can be found in:
+- [Simple example](https://github.com/vadikko2/python-cqrs/blob/master/examples/dependency_injector_integration_simple_example.py)
+- [Practical example with FastAPI](https://github.com/vadikko2/python-cqrs/blob/master/examples/dependency_injector_integration_practical_example.py)
+
+## Bootstrap
+
+The `python-cqrs` package implements a set of bootstrap utilities designed to simplify the initial configuration of an
+application.
+
+```python
+import functools
+
+from cqrs.events import bootstrap as event_bootstrap
+from cqrs.requests import bootstrap as request_bootstrap
+
+from app import dependencies, mapping, orm
+
+
+@functools.lru_cache
+def mediator_factory():
+    return request_bootstrap.bootstrap(
+        di_container=dependencies.setup_di(),
+        commands_mapper=mapping.init_commands,
+        queries_mapper=mapping.init_queries,
+        domain_events_mapper=mapping.init_events,
+        on_startup=[orm.init_store_event_mapper],
+    )
+
+
+@functools.lru_cache
+def event_mediator_factory():
+    return event_bootstrap.bootstrap(
+        di_container=dependencies.setup_di(),
+        events_mapper=mapping.init_events,
+        on_startup=[orm.init_store_event_mapper],
+    )
+
+
+@functools.lru_cache
+def saga_mediator_factory():
+    return saga_bootstrap.bootstrap(
+        di_container=dependencies.setup_di(),
+        sagas_mapper=mapping.init_sagas,
+        domain_events_mapper=mapping.init_events,
+        saga_storage=MemorySagaStorage(),
+    )
+```
 
 ## Saga Pattern
 
@@ -244,6 +544,7 @@ Sagas enable eventual consistency by executing a series of steps where each step
 - **SagaLog**: Tracks all step executions (act/compensate) with status and timestamps
 - **Recovery Mechanism**: Automatically recovers interrupted sagas from storage, ensuring eventual consistency
 - **Automatic Compensation**: If any step fails, all previously completed steps are automatically compensated in reverse order
+- **Fallback Pattern**: Define alternative steps to execute when primary steps fail, with optional Circuit Breaker protection
 - **Mermaid Diagram Generation**: Generate Sequence and Class diagrams for documentation and visualization
 
 ### Example
@@ -280,6 +581,57 @@ async for step_result in mediator.stream(context, saga_id=saga_id):
     # If any step fails, compensation happens automatically
 ```
 
+### Fallback Pattern with Circuit Breaker
+
+The saga pattern supports fallback steps that execute automatically when primary steps fail. You can also integrate Circuit Breaker protection to prevent cascading failures:
+
+```python
+from cqrs.saga.fallback import Fallback
+from cqrs.adapters.circuit_breaker import AioBreakerAdapter
+from cqrs.response import Response
+from cqrs.saga.step import SagaStepHandler, SagaStepResult
+
+class ReserveInventoryResponse(Response):
+    reservation_id: str
+
+class PrimaryStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+    async def act(self, context: OrderContext) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        # Primary step that may fail
+        raise RuntimeError("Service unavailable")
+
+class FallbackStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+    async def act(self, context: OrderContext) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        # Alternative step that executes when primary fails
+        reservation_id = f"fallback_reservation_{context.order_id}"
+        context.reservation_id = reservation_id
+        return self._generate_step_result(ReserveInventoryResponse(reservation_id=reservation_id))
+
+# Define saga with fallback and circuit breaker
+class OrderSagaWithFallback(Saga[OrderContext]):
+    steps = [
+        Fallback(
+            step=PrimaryStep,
+            fallback=FallbackStep,
+            circuit_breaker=AioBreakerAdapter(
+                fail_max=2,  # Circuit opens after 2 failures
+                timeout_duration=60,  # Wait 60 seconds before retry
+            ),
+        ),
+    ]
+
+# Optional: Using Redis for distributed circuit breaker state
+# import redis
+# from aiobreaker.storage.redis import CircuitRedisStorage
+#
+# def redis_storage_factory(name: str):
+#     client = redis.from_url("redis://localhost:6379", decode_responses=False)
+#     return CircuitRedisStorage(state="closed", redis_object=client, namespace=name)
+#
+# AioBreakerAdapter(..., storage_factory=redis_storage_factory)
+```
+
+When the primary step fails, the fallback step executes automatically. The Circuit Breaker opens after the configured failure threshold, preventing unnecessary load on failing services by failing fast.
+
 The saga state and step history are persisted to `SagaStorage`. The `SagaLog` maintains a complete audit trail
 of all step executions (both `act` and `compensate` operations) with timestamps and status information.
 This enables the recovery mechanism to restore saga state and ensure eventual consistency even after system failures.
@@ -332,68 +684,7 @@ sequence_diagram = generator.sequence()
 class_diagram = generator.class_diagram()
 ```
 
-Complete example: [Saga Mermaid Diagrams](https://github.com/vadikko2/cqrs/blob/master/examples/saga_mermaid.py)
-
-## Event Handlers
-
-Event handlers are designed to process `Notification` and `ECST` events that are consumed from the broker.
-To configure event handling, you need to implement a broker consumer on the side of your application.
-Below is an example of `Kafka event consuming` that can be used in the Presentation Layer.
-
-```python
-class JoinMeetingCommandHandler(cqrs.RequestHandler[JoinMeetingCommand, None]):
-    def __init__(self):
-        self._events = []
-
-    @property
-    def events(self):
-        return self._events
-
-    async def handle(self, request: JoinMeetingCommand) -> None:
-        STORAGE[request.meeting_id].append(request.user_id)
-        self._events.append(
-            UserJoined(user_id=request.user_id, meeting_id=request.meeting_id),
-        )
-        print(f"User {request.user_id} joined meeting {request.meeting_id}")
-
-
-class UserJoinedEventHandler(cqrs.EventHandler[UserJoined]):
-    async def handle(self, event: UserJoined) -> None:
-        print(f"Handle user {event.user_id} joined meeting {event.meeting_id} event")
-```
-
-A complete example can be found in
-the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/domain_event_handler.py)
-
-### Parallel Event Processing
-
-Both `RequestMediator` and `StreamingRequestMediator` support parallel processing of domain events. You can control
-the number of event handlers that run simultaneously using the `max_concurrent_event_handlers` parameter.
-
-This feature is especially useful when:
-- Multiple event handlers need to process events independently
-- You want to improve performance by processing events concurrently
-- You need to limit resource consumption by controlling concurrency
-
-**Configuration:**
-
-```python
-from cqrs.requests import bootstrap
-
-mediator = bootstrap.bootstrap_streaming(
-    di_container=container,
-    commands_mapper=commands_mapper,
-    domain_events_mapper=domain_events_mapper,
-    message_broker=broker,
-    max_concurrent_event_handlers=3,  # Process up to 3 events in parallel
-    concurrent_event_handle_enable=True,  # Enable parallel processing
-)
-```
-
-> [!TIP]
-> - Set `max_concurrent_event_handlers` to limit the number of simultaneously running event handlers
-> - Set `concurrent_event_handle_enable=False` to disable parallel processing and process events sequentially
-> - The default value for `max_concurrent_event_handlers` is `10` for `StreamingRequestMediator` and `1` for `RequestMediator`
+Complete example: [Saga Mermaid Diagrams](https://github.com/vadikko2/python-cqrs/blob/master/examples/saga_mermaid.py)
 
 ## Producing Notification Events
 
@@ -433,7 +724,7 @@ class JoinMeetingCommandHandler(cqrs.RequestHandler[JoinMeetingCommand, None]):
 ```
 
 A complete example can be found in
-the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/event_producing.py)
+the [documentation](https://github.com/vadikko2/python-cqrs/blob/master/examples/event_producing.py)
 
 After processing the command/request, if there are any Notification/ECST events,
 the EventEmitter is invoked to produce the events via the message broker.
@@ -468,13 +759,6 @@ The package implements the [Transactional Outbox](https://microservices.io/patte
 pattern, which ensures that messages are produced to the broker according to the at-least-once semantics.
 
 ```python
-def do_some_logic(meeting_room_id: int, session: sql_session.AsyncSession):
-    """
-    Make changes to the database
-    """
-    session.add(...)
-
-
 class JoinMeetingCommandHandler(cqrs.RequestHandler[JoinMeetingCommand, None]):
     def __init__(self, outbox: cqrs.OutboxedEventRepository):
         self.outbox = outbox
@@ -485,35 +769,33 @@ class JoinMeetingCommandHandler(cqrs.RequestHandler[JoinMeetingCommand, None]):
 
     async def handle(self, request: JoinMeetingCommand) -> None:
         print(f"User {request.user_id} joined meeting {request.meeting_id}")
-        async with self.outbox as session:
-            do_some_logic(request.meeting_id, session) # business logic
-            self.outbox.add(
-                session,
-                cqrs.NotificationEvent[UserJoinedNotificationPayload](
-                    event_name="UserJoined",
-                    topic="user_notification_events",
-                    payload=UserJoinedNotificationPayload(
-                        user_id=request.user_id,
-                        meeting_id=request.meeting_id,
-                    ),
+        # Outbox repository is bound to a session (e.g. via DI request scope).
+        # add() takes only the event; commit() persists the outbox and your changes.
+        self.outbox.add(
+            cqrs.NotificationEvent[UserJoinedNotificationPayload](
+                event_name="UserJoined",
+                topic="user_notification_events",
+                payload=UserJoinedNotificationPayload(
+                    user_id=request.user_id,
+                    meeting_id=request.meeting_id,
                 ),
-            )
-            self.outbox.add(
-                session,
-                cqrs.NotificationEvent[UserJoinedECSTPayload](
-                    event_name="UserJoined",
-                    topic="user_ecst_events",
-                    payload=UserJoinedECSTPayload(
-                        user_id=request.user_id,
-                        meeting_id=request.meeting_id,
-                    ),
+            ),
+        )
+        self.outbox.add(
+            cqrs.NotificationEvent[UserJoinedECSTPayload](
+                event_name="UserJoined",
+                topic="user_ecst_events",
+                payload=UserJoinedECSTPayload(
+                    user_id=request.user_id,
+                    meeting_id=request.meeting_id,
                 ),
-            )
-            await self.outbox.commit(session)
+            ),
+        )
+        await self.outbox.commit()
 ```
 
 A complete example can be found in
-the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/save_events_into_outbox.py)
+the [documentation](https://github.com/vadikko2/python-cqrs/blob/master/examples/save_events_into_outbox.py)
 
 > [!TIP]
 > You can specify the name of the Outbox table using the environment variable `OUTBOX_SQLA_TABLE`.
@@ -521,8 +803,8 @@ the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/save_e
 
 > [!TIP]
 > If you use the protobuf events you should specify `OutboxedEventRepository`
-> by [protobuf serialize](https://github.com/vadikko2/cqrs/blob/master/src/cqrs/serializers/protobuf.py). A complete example can be found in
-the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/save_proto_events_into_outbox.py)
+> by [protobuf serialize](https://github.com/vadikko2/python-cqrs/blob/master/src/cqrs/serializers/protobuf.py). A complete example can be found in
+the [documentation](https://github.com/vadikko2/python-cqrs/blob/master/examples/save_proto_events_into_outbox.py)
 
 ## Producing Events from Outbox to Kafka
 
@@ -548,23 +830,20 @@ broker = kafka.KafkaMessageBroker(
    producer=kafka_adapters.kafka_producer_factory(dsn="localhost:9092"),
 )
 
-producer = cqrs.EventProducer(broker, cqrs.SqlAlchemyOutboxedEventRepository(session_factory, zlib.ZlibCompressor()))
-
+# SqlAlchemyOutboxedEventRepository expects (session, compressor), not session_factory.
+async with session_factory() as session:
+    repository = cqrs.SqlAlchemyOutboxedEventRepository(session, zlib.ZlibCompressor())
+    producer = cqrs.EventProducer(broker, repository)
 
-async def periodically_task():
-   async for messages in producer.event_batch_generator():
-      for message in messages:
-         await producer.send_message(message)
-      await producer.repository.commit()
-      await asyncio.sleep(10)
-
-
-loop = asyncio.get_event_loop()
-loop.run_until_complete(periodically_task())
+    async for messages in producer.event_batch_generator():
+        for message in messages:
+            await producer.send_message(message)
+        await producer.repository.commit()
+        await asyncio.sleep(10)
 ```
 
 A complete example can be found in
-the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/kafka_outboxed_event_producing.py)
+the [documentation](https://github.com/vadikko2/python-cqrs/blob/master/examples/kafka_outboxed_event_producing.py)
 
 ## Transaction log tailing
 
@@ -578,129 +857,71 @@ The current version of the python-cqrs package does not support the implementati
 > which allows you to produce all newly created events within the Outbox storage directly to the corresponding topic in
 > Kafka (or any other broker).
 
-## DI container
-
-Use the following example to set up dependency injection in your command, query and event handlers. This will make
-dependency management simpler.
-
-The package supports two DI container libraries:
+## Event Handlers
 
-### di library
+Event handlers are designed to process `Notification` and `ECST` events that are consumed from the broker.
+To configure event handling, you need to implement a broker consumer on the side of your application.
+Below is an example of `Kafka event consuming` that can be used in the Presentation Layer.
 
 ```python
-import di
-...
+class JoinMeetingCommandHandler(cqrs.RequestHandler[JoinMeetingCommand, None]):
+    def __init__(self):
+        self._events = []
 
-def setup_di() -> di.Container:
-    """
-    Binds implementations to dependencies
-    """
-    container = di.Container()
-    container.bind(
-        di.bind_by_type(
-            dependent.Dependent(cqrs.SqlAlchemyOutboxedEventRepository, scope="request"),
-            cqrs.OutboxedEventRepository
-        )
-    )
-    container.bind(
-        di.bind_by_type(
-            dependent.Dependent(MeetingAPIImplementaion, scope="request"),
-            MeetingAPIProtocol
+    @property
+    def events(self):
+        return self._events
+
+    async def handle(self, request: JoinMeetingCommand) -> None:
+        STORAGE[request.meeting_id].append(request.user_id)
+        self._events.append(
+            UserJoined(user_id=request.user_id, meeting_id=request.meeting_id),
         )
-    )
-    return container
+        print(f"User {request.user_id} joined meeting {request.meeting_id}")
+
+
+class UserJoinedEventHandler(cqrs.EventHandler[UserJoined]):
+    async def handle(self, event: UserJoined) -> None:
+        print(f"Handle user {event.user_id} joined meeting {event.meeting_id} event")
 ```
 
 A complete example can be found in
-the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/dependency_injection.py)
+the [documentation](https://github.com/vadikko2/python-cqrs/blob/master/examples/domain_event_handler.py)
 
-### dependency-injector library
+### Parallel Event Processing
 
-The package also supports [dependency-injector](https://github.com/ets-labs/python-dependency-injector) library.
-You can use `DependencyInjectorCQRSContainer` adapter to integrate dependency-injector containers with python-cqrs.
+Both `RequestMediator` and `StreamingRequestMediator` support parallel processing of domain events. You can control
+the number of event handlers that run simultaneously using the `max_concurrent_event_handlers` parameter.
 
-```python
-from dependency_injector import containers, providers
-from cqrs.container.dependency_injector import DependencyInjectorCQRSContainer
+This feature is especially useful when:
+- Multiple event handlers need to process events independently
+- You want to improve performance by processing events concurrently
+- You need to limit resource consumption by controlling concurrency
 
-class ApplicationContainer(containers.DeclarativeContainer):
-    # Define your providers
-    service = providers.Factory(ServiceImplementation)
+**Configuration:**
 
-# Create CQRS container adapter
-cqrs_container = DependencyInjectorCQRSContainer(ApplicationContainer())
+```python
+from cqrs.requests import bootstrap
 
-# Use with bootstrap
-mediator = bootstrap.bootstrap(
-    di_container=cqrs_container,
+mediator = bootstrap.bootstrap_streaming(
+    di_container=container,
     commands_mapper=commands_mapper,
-    ...
+    domain_events_mapper=domain_events_mapper,
+    message_broker=broker,
+    max_concurrent_event_handlers=3,  # Process up to 3 events in parallel
+    concurrent_event_handle_enable=True,  # Enable parallel processing
 )
 ```
 
-Complete examples can be found in:
-- [Simple example](https://github.com/vadikko2/cqrs/blob/master/examples/dependency_injector_integration_simple_example.py)
-- [Practical example with FastAPI](https://github.com/vadikko2/cqrs/blob/master/examples/dependency_injector_integration_practical_example.py)
-
-## Mapping
-
-To bind commands, queries and events with specific handlers, you can use the registries `EventMap` and `RequestMap`.
-
-```python
-from cqrs import requests, events
-
-from app import commands, command_handlers
-from app import queries, query_handlers
-from app import events as event_models, event_handlers
-
-
-def init_commands(mapper: requests.RequestMap) -> None:
-    mapper.bind(commands.JoinMeetingCommand, command_handlers.JoinMeetingCommandHandler)
-
-def init_queries(mapper: requests.RequestMap) -> None:
-    mapper.bind(queries.ReadMeetingQuery, query_handlers.ReadMeetingQueryHandler)
-
-def init_events(mapper: events.EventMap) -> None:
-    mapper.bind(events.NotificationEvent[events_models.NotificationMeetingRoomClosed], event_handlers.MeetingRoomClosedNotificationHandler)
-    mapper.bind(events.NotificationEvent[event_models.ECSTMeetingRoomClosed], event_handlers.UpdateMeetingRoomReadModelHandler)
-```
-
-## Bootstrap
-
-The `python-cqrs` package implements a set of bootstrap utilities designed to simplify the initial configuration of an
-application.
-
-```python
-import functools
-
-from cqrs.events import bootstrap as event_bootstrap
-from cqrs.requests import bootstrap as request_bootstrap
-
-from app import dependencies, mapping, orm
-
-
-@functools.lru_cache
-def mediator_factory():
-    return request_bootstrap.bootstrap(
-        di_container=dependencies.setup_di(),
-        commands_mapper=mapping.init_commands,
-        queries_mapper=mapping.init_queries,
-        domain_events_mapper=mapping.init_events,
-        on_startup=[orm.init_store_event_mapper],
-    )
-
-
-@functools.lru_cache
-def event_mediator_factory():
-    return event_bootstrap.bootstrap(
-        di_container=dependencies.setup_di(),
-        events_mapper=mapping.init_events,
-        on_startup=[orm.init_store_event_mapper],
-    )
-```
+> [!TIP]
+> - Set `max_concurrent_event_handlers` to limit the number of simultaneously running event handlers
+> - Set `concurrent_event_handle_enable=False` to disable parallel processing and process events sequentially
+> - The default value for `max_concurrent_event_handlers` is `10` for `StreamingRequestMediator` and `1` for `RequestMediator`
 
 ## Integration with presentation layers
 
+The framework is ready for integration with **FastAPI** and **FastStream**.
+
 > [!TIP]
 > I recommend reading the useful
 > paper [Onion Architecture Used in Software Development](https://www.researchgate.net/publication/371006360_Onion_Architecture_Used_in_Software_Development).
@@ -717,7 +938,7 @@ In this case you can use python-cqrs to route requests to the appropriate handle
 import fastapi
 import pydantic
 
-from app import dependecies, commands
+from app import dependencies, commands
 
 router = fastapi.APIRouter(prefix="/meetings")
 
@@ -733,7 +954,7 @@ async def join_metting(
 ```
 
 A complete example can be found in
-the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/fastapi_integration.py)
+the [documentation](https://github.com/vadikko2/python-cqrs/blob/master/examples/fastapi_integration.py)
 
 ### Kafka events consuming
 
@@ -811,16 +1032,16 @@ async def process_files_stream(
     mediator: cqrs.StreamingRequestMediator = fastapi.Depends(streaming_mediator_factory),
 ) -> fastapi.responses.StreamingResponse:
     async def generate_sse():
-        yield f"data: {json.dumps({'type': 'start', 'message': 'Processing...'})}\n\n"
+        yield f"data: {json.dumps({'type': 'start', 'message': 'Processing...'})}\\n\\n"
 
         async for result in mediator.stream(command):
             sse_data = {
                 "type": "progress",
-                "data": result.model_dump(),
+                "data": result.to_dict(),
             }
-            yield f"data: {json.dumps(sse_data)}\n\n"
+            yield f"data: {json.dumps(sse_data)}\\n\\n"
 
-        yield f"data: {json.dumps({'type': 'complete'})}\n\n"
+        yield f"data: {json.dumps({'type': 'complete'})}\\n\\n"
 
     return fastapi.responses.StreamingResponse(
         generate_sse(),
@@ -829,12 +1050,71 @@ async def process_files_stream(
 ```
 
 A complete example can be found in
-the [documentation](https://github.com/vadikko2/cqrs/blob/master/examples/fastapi_sse_streaming.py)
+the [documentation](https://github.com/vadikko2/python-cqrs/blob/master/examples/fastapi_sse_streaming.py)
 
 ## Protobuf messaging
 
-The `python-cqrs` package supports integration with [protobuf](https://developers.google.com/protocol-buffers/).\
-Protocol buffers are Google’s language-neutral, platform-neutral, extensible mechanism for serializing structured data –
-think XML, but smaller, faster, and simpler. You define how you want your data to be structured once, then you can use
-special generated source code to easily write and read your structured data to and from a variety of data streams and
-using a variety of languages.
+The `python-cqrs` package supports integration with [protobuf](https://developers.google.com/protocol-buffers/).
+Notification events can be serialized to Protobuf and back: implement the `proto()` method (returns a protobuf message) and the class method `from_proto()` (creates an event instance from proto) on your event class.
+
+Example (assuming generated `user_joined_pb2` from your `.proto` with fields `event_id`, `event_timestamp`, `event_name`, `payload`):
+
+```python
+import uuid
+from datetime import datetime
+
+import cqrs
+from app.generated import user_joined_pb2  # generated from .proto
+
+
+class UserJoinedPayload(cqrs.Response):
+    user_id: str
+    meeting_id: str
+
+
+class UserJoinedNotificationEvent(cqrs.NotificationEvent[UserJoinedPayload]):
+    """Event with Protobuf serialization support."""
+
+    event_name: str = "UserJoined"
+
+    def proto(self):
+        msg = user_joined_pb2.UserJoinedNotification()
+        msg.event_id = str(self.event_id)
+        msg.event_timestamp = self.event_timestamp.isoformat()
+        msg.event_name = self.event_name
+        msg.payload.user_id = self.payload.user_id
+        msg.payload.meeting_id = self.payload.meeting_id
+        return msg
+
+    @classmethod
+    def from_proto(cls, proto_msg):
+        return cls(
+            event_id=uuid.UUID(proto_msg.event_id),
+            event_timestamp=datetime.fromisoformat(proto_msg.event_timestamp),
+            event_name=proto_msg.event_name,
+            topic="user_notification_events",
+            payload=UserJoinedPayload(
+                user_id=proto_msg.payload.user_id,
+                meeting_id=proto_msg.payload.meeting_id,
+            ),
+        )
+```
+
+## Contributing
+
+Contributions are welcome. To develop locally:
+
+1. Clone the repository and create a virtual environment.
+2. Install dev dependencies: `pip install -e ".[dev]"`.
+3. Run tests: `pytest`.
+4. Install pre-commit and run hooks: `pre-commit install && pre-commit run --all-files`.
+
+The project uses [ruff](https://docs.astral.sh/ruff/) for linting and [pyright](https://microsoft.github.io/pyright/) for type checking.
+
+## Changelog
+
+Release notes and migration guides are published on [GitHub Releases](https://github.com/vadikko2/python-cqrs/releases).
+
+## License
+
+This project is licensed under the MIT License — see the [LICENSE](LICENSE) file for details.
diff --git a/docker-compose-dev.yml b/docker-compose-dev.yml
index 1fa5bce..fdb209c 100644
--- a/docker-compose-dev.yml
+++ b/docker-compose-dev.yml
@@ -15,6 +15,16 @@ services:
     command: --init-file /data/application/init.sql
     volumes:
       - ./tests/init_database.sql:/data/application/init.sql
+  postgres_dev:
+    image: postgres:15.4
+    hostname: postgres-dev
+    restart: always
+    environment:
+      POSTGRES_USER: cqrs
+      POSTGRES_PASSWORD: cqrs
+      POSTGRES_DB: cqrs
+    ports:
+      - "5433:5432"
   kafka0:
     image: confluentinc/cp-kafka:7.2.1
     hostname: kafka0
@@ -42,3 +52,8 @@ services:
     volumes:
       - ./scripts/update_run.sh:/tmp/update_run.sh
     command: "bash -c 'if [ ! -f /tmp/update_run.sh ]; then echo \"ERROR: Did you forget the update_run.sh file that came with this docker-compose.yml file?\" && exit 1 ; else /tmp/update_run.sh && /etc/confluent/docker/run ; fi'"
+  redis:
+    image: redis:7.2
+    hostname: redis
+    ports:
+      - "6379:6379"
diff --git a/docker-compose-test.yml b/docker-compose-test.yml
new file mode 100644
index 0000000..60394a4
--- /dev/null
+++ b/docker-compose-test.yml
@@ -0,0 +1,32 @@
+version: '3'
+services:
+  mysql_tests:
+    image: mysql:8.3.0
+    hostname: mysql-dev
+    restart: always
+    environment:
+      MYSQL_PORT: 3306
+      MYSQL_ROOT_PASSWORD: root
+      MYSQL_DATABASE: cqrs
+      MYSQL_USER: cqrs
+      MYSQL_PASSWORD: cqrs
+    ports:
+      - 3307:3306
+    command: --init-file /data/application/init.sql
+    volumes:
+      - ./tests/init_database.sql:/data/application/init.sql
+  postgres_tests:
+    image: postgres:15.4
+    hostname: postgres-test
+    restart: always
+    environment:
+      POSTGRES_USER: cqrs
+      POSTGRES_PASSWORD: cqrs
+      POSTGRES_DB: cqrs
+    ports:
+      - "5433:5432"
+  redis_tests:
+    image: redis:7.2
+    hostname: redis
+    ports:
+      - "6379:6379"
diff --git a/examples/cor_request_fallback.py b/examples/cor_request_fallback.py
new file mode 100644
index 0000000..0a193cc
--- /dev/null
+++ b/examples/cor_request_fallback.py
@@ -0,0 +1,247 @@
+"""
+Example: Chain of Responsibility with Request Handler Fallback
+
+This example shows how to combine a COR (Chain of Responsibility) handler
+with RequestHandlerFallback. The primary handler is a RequestHandler that
+delegates to a COR chain; when the chain raises (e.g. downstream failure),
+the fallback handler is invoked.
+
+Use case: A request is first tried through a chain of handlers (e.g. try
+cache, then DB, then external API). If the whole chain fails (e.g. connection
+error), a fallback handler returns a default/cached response.
+
+================================================================================
+HOW TO RUN THIS EXAMPLE
+================================================================================
+
+Run the example:
+   python examples/cor_request_fallback.py
+
+The example will:
+- Send a command that is handled by a COR chain (primary path)
+- For source="error", the chain raises and fallback handler runs
+- For source="a" or "b", the chain handles the request successfully
+
+================================================================================
+WHAT THIS EXAMPLE DEMONSTRATES
+================================================================================
+
+1. RequestHandlerFallback with COR as primary:
+   - Primary is a RequestHandler that delegates to a COR chain (injected via DI).
+   - Fallback is a simple RequestHandler used when the chain raises.
+
+2. Building the chain:
+   - Create COR handler instances, build_chain(), then bind the chain entry
+     (first handler) in the container so the wrapper can receive it.
+
+3. Flow:
+   - mediator.send(request) dispatches to primary (CORChainWrapperHandler).
+   - Wrapper calls the chain; if the chain raises, dispatcher catches and
+     invokes fallback.
+
+4. Optional failure_exceptions:
+   - Restrict fallback to specific exception types (e.g. ConnectionError).
+
+================================================================================
+REQUIREMENTS
+================================================================================
+
+Make sure you have installed:
+   - cqrs (this package)
+   - di (dependency injection)
+
+================================================================================
+"""
+
+import asyncio
+import logging
+
+import di
+from di import dependent
+
+import cqrs
+from cqrs.requests import bootstrap
+from cqrs.requests.cor_request_handler import (
+    CORRequestHandler,
+    build_chain,
+)
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+HANDLER_SOURCE: list[str] = []  # "chain" or "fallback"
+
+
+# -----------------------------------------------------------------------------
+# Command and response
+# -----------------------------------------------------------------------------
+
+
+class FetchDataCommand(cqrs.Request):
+    source: str  # "a" | "b" | "error"
+
+
+class FetchDataResult(cqrs.Response):
+    data: str
+    source: str  # "chain" or "fallback"
+
+
+# -----------------------------------------------------------------------------
+# COR handlers (chain)
+# -----------------------------------------------------------------------------
+
+
+class SourceAHandler(CORRequestHandler[FetchDataCommand, FetchDataResult]):
+    @property
+    def events(self) -> list[cqrs.Event]:
+        return []
+
+    async def handle(self, request: FetchDataCommand) -> FetchDataResult | None:
+        if request.source == "a":
+            logger.info("COR chain: SourceAHandler handled source=a")
+            HANDLER_SOURCE.append("chain")
+            return FetchDataResult(data="data_from_a", source="chain")
+        return await self.next(request)
+
+
+class SourceBHandler(CORRequestHandler[FetchDataCommand, FetchDataResult]):
+    @property
+    def events(self) -> list[cqrs.Event]:
+        return []
+
+    async def handle(self, request: FetchDataCommand) -> FetchDataResult | None:
+        if request.source == "b":
+            logger.info("COR chain: SourceBHandler handled source=b")
+            HANDLER_SOURCE.append("chain")
+            return FetchDataResult(data="data_from_b", source="chain")
+        return await self.next(request)
+
+
+class DefaultChainHandler(CORRequestHandler[FetchDataCommand, FetchDataResult]):
+    """Last in chain: handles unknown or raises for source='error'."""
+
+    @property
+    def events(self) -> list[cqrs.Event]:
+        return []
+
+    async def handle(self, request: FetchDataCommand) -> FetchDataResult | None:
+        if request.source == "error":
+            logger.info("COR chain: DefaultChainHandler raising ConnectionError for source=error")
+            raise ConnectionError("Downstream service unavailable")
+        logger.info("COR chain: DefaultChainHandler handled (unknown source)")
+        HANDLER_SOURCE.append("chain")
+        return FetchDataResult(data="default_data", source="chain")
+
+
+# -----------------------------------------------------------------------------
+# Wrapper: RequestHandler that delegates to the COR chain
+# -----------------------------------------------------------------------------
+
+
+class CORChainWrapperHandler(
+    cqrs.RequestHandler[FetchDataCommand, FetchDataResult],
+):
+    """Primary 'handler' that runs the COR chain; chain is injected as the first link."""
+
+    def __init__(self, chain_entry: SourceAHandler) -> None:
+        self._chain_entry = chain_entry
+
+    @property
+    def events(self) -> list[cqrs.Event]:
+        return []
+
+    async def handle(self, request: FetchDataCommand) -> FetchDataResult:
+        result = await self._chain_entry.handle(request)
+        if result is None:
+            raise ValueError("COR chain did not handle the request")
+        return result
+
+
+# -----------------------------------------------------------------------------
+# Fallback handler (used when the chain raises)
+# -----------------------------------------------------------------------------
+
+
+class FallbackFetchDataHandler(
+    cqrs.RequestHandler[FetchDataCommand, FetchDataResult],
+):
+    @property
+    def events(self) -> list[cqrs.Event]:
+        return []
+
+    async def handle(self, request: FetchDataCommand) -> FetchDataResult:
+        logger.info("Fallback handler: returning cached/default for source=%s", request.source)
+        HANDLER_SOURCE.append("fallback")
+        return FetchDataResult(
+            data="cached_or_default",
+            source="fallback",
+        )
+
+
+# -----------------------------------------------------------------------------
+# Mappers and bootstrap
+# -----------------------------------------------------------------------------
+
+
+def commands_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(
+        FetchDataCommand,
+        cqrs.RequestHandlerFallback(
+            primary=CORChainWrapperHandler,
+            fallback=FallbackFetchDataHandler,
+            failure_exceptions=(ConnectionError, TimeoutError),
+        ),
+    )
+
+
+async def main() -> None:
+    HANDLER_SOURCE.clear()
+
+    # Build COR chain and inject the chain entry so CORChainWrapperHandler gets it
+    source_a = SourceAHandler()
+    source_b = SourceBHandler()
+    default = DefaultChainHandler()
+    build_chain([source_a, source_b, default])
+
+    di_container = di.Container()
+    di_container.bind(
+        di.bind_by_type(
+            dependent.Dependent(lambda: source_a, scope="request"),
+            SourceAHandler,
+        ),
+    )
+
+    mediator = bootstrap.bootstrap(
+        di_container=di_container,
+        commands_mapper=commands_mapper,
+    )
+
+    print("\n" + "=" * 60)
+    print("COR REQUEST HANDLER FALLBACK EXAMPLE")
+    print("=" * 60)
+
+    # Case 1: chain handles (source=a)
+    print("\n1. Send FetchDataCommand(source='a') — chain handles")
+    result1: FetchDataResult = await mediator.send(FetchDataCommand(source="a"))
+    print(f"   Result: data={result1.data}, source={result1.source}")
+    assert result1.source == "chain" and result1.data == "data_from_a"
+
+    # Case 2: chain handles (source=b)
+    print("\n2. Send FetchDataCommand(source='b') — chain handles")
+    result2: FetchDataResult = await mediator.send(FetchDataCommand(source="b"))
+    print(f"   Result: data={result2.data}, source={result2.source}")
+    assert result2.source == "chain" and result2.data == "data_from_b"
+
+    # Case 3: chain raises (source=error) -> fallback runs
+    print("\n3. Send FetchDataCommand(source='error') — chain raises, fallback runs")
+    result3: FetchDataResult = await mediator.send(FetchDataCommand(source="error"))
+    print(f"   Result: data={result3.data}, source={result3.source}")
+    assert result3.source == "fallback" and result3.data == "cached_or_default"
+
+    print("\n   Handlers that ran (in order): " + str(HANDLER_SOURCE))
+    assert "chain" in HANDLER_SOURCE and "fallback" in HANDLER_SOURCE
+    print("\n" + "=" * 60 + "\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/dependency_injector_integration_practical_example.py b/examples/dependency_injector_integration_practical_example.py
index 4e28673..5c4e965 100644
--- a/examples/dependency_injector_integration_practical_example.py
+++ b/examples/dependency_injector_integration_practical_example.py
@@ -68,7 +68,13 @@
 from abc import ABC, abstractmethod
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
-from typing import Generic, Optional, Self, TypeVar
+import sys
+from typing import Generic, Optional, TypeVar
+
+if sys.version_info >= (3, 11):
+    from typing import Self  # novm
+else:
+    from typing_extensions import Self
 
 import uvicorn
 
@@ -345,9 +351,7 @@ def setup_logging() -> None:
     )
 
     # Add a StreamHandler if none exists
-    has_stream_handler = any(
-        isinstance(h, logging.StreamHandler) for h in root_logger.handlers
-    )
+    has_stream_handler = any(isinstance(h, logging.StreamHandler) for h in root_logger.handlers)
     if not has_stream_handler:
         stream_handler = logging.StreamHandler()
         stream_handler.setLevel(logging.DEBUG)
diff --git a/examples/event_fallback.py b/examples/event_fallback.py
new file mode 100644
index 0000000..95ef7cb
--- /dev/null
+++ b/examples/event_fallback.py
@@ -0,0 +1,222 @@
+"""
+Example: Event Handler Fallback with Optional Circuit Breaker
+
+This example demonstrates the EventHandlerFallback pattern for domain event
+handlers. When the primary event handler fails (or the circuit breaker is open),
+the fallback handler is invoked. This is useful for resilient side effects
+such as sending notifications or updating read models when the primary path
+(e.g. external API) is unavailable.
+
+================================================================================
+HOW TO RUN THIS EXAMPLE
+================================================================================
+
+Run the example (without circuit breaker):
+   python examples/event_fallback.py
+
+With circuit breaker (optional dependency):
+   pip install aiobreaker
+   python examples/event_fallback.py
+
+The example will:
+- Execute a command that emits a domain event
+- Primary event handler fails (simulated external service failure)
+- Fallback event handler runs and completes successfully
+- With circuit breaker: after N failures the circuit opens and fallback is
+  used without calling the primary handler
+
+================================================================================
+WHAT THIS EXAMPLE DEMONSTRATES
+================================================================================
+
+1. EventHandlerFallback Registration:
+   - Bind event type to EventHandlerFallback(primary, fallback, ...)
+   - Optional failure_exceptions to trigger fallback only for specific errors
+   - Optional circuit_breaker (e.g. AioBreakerAdapter) per domain
+
+2. Primary and Fallback Handlers:
+   - Primary handler implements EventHandler[EventType]; can raise
+   - Fallback handler implements same event type; runs when primary fails
+
+3. Flow:
+   - Command handler emits domain event
+   - EventEmitter runs handlers; for EventHandlerFallback runs primary first
+   - On primary exception (or circuit open): fallback handler is invoked
+   - Events from the handler that actually ran are collected and returned
+
+4. Circuit Breaker (optional):
+   - Use one AioBreakerAdapter instance per domain (e.g. events)
+   - After fail_max failures, circuit opens; primary is not called, fallback runs
+
+================================================================================
+REQUIREMENTS
+================================================================================
+
+Make sure you have installed:
+   - cqrs (this package)
+   - di (dependency injection)
+
+Optional for circuit breaker:
+   pip install aiobreaker
+   or: pip install python-cqrs[aiobreaker]
+
+================================================================================
+"""
+
+import asyncio
+import logging
+import di
+
+import cqrs
+from cqrs.adapters.circuit_breaker import AioBreakerAdapter
+from cqrs.requests import bootstrap
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Track which handler ran for demo output
+EVENTS_HANDLED_BY: list[str] = []
+
+
+# -----------------------------------------------------------------------------
+# Command and domain event
+# -----------------------------------------------------------------------------
+
+
+class SendNotificationCommand(cqrs.Request):
+    user_id: str
+    message: str
+
+
+class NotificationSent(cqrs.DomainEvent, frozen=True):
+    user_id: str
+    message: str
+
+
+# -----------------------------------------------------------------------------
+# Command handler (emits domain event)
+# -----------------------------------------------------------------------------
+
+
+class SendNotificationCommandHandler(cqrs.RequestHandler[SendNotificationCommand, None]):
+    @property
+    def events(self) -> list[cqrs.Event]:
+        return self._events
+
+    def __init__(self) -> None:
+        self._events: list[cqrs.Event] = []
+
+    async def handle(self, request: SendNotificationCommand) -> None:
+        self._events.append(
+            NotificationSent(user_id=request.user_id, message=request.message),
+        )
+        logger.info("Command: emitted NotificationSent for user %s", request.user_id)
+
+
+# -----------------------------------------------------------------------------
+# Primary event handler (simulates failure – e.g. external notification API down)
+# -----------------------------------------------------------------------------
+
+
+class PrimaryNotificationSentHandler(cqrs.EventHandler[NotificationSent]):
+    async def handle(self, event: NotificationSent) -> None:
+        logger.info(
+            "Primary handler: would send notification to user %s: %s",
+            event.user_id,
+            event.message,
+        )
+        EVENTS_HANDLED_BY.append("primary")
+        raise RuntimeError("External notification service unavailable")
+
+
+# -----------------------------------------------------------------------------
+# Fallback event handler (e.g. write to local queue or log)
+# -----------------------------------------------------------------------------
+
+
+class FallbackNotificationSentHandler(cqrs.EventHandler[NotificationSent]):
+    async def handle(self, event: NotificationSent) -> None:
+        logger.info(
+            "Fallback handler: enqueue notification for user %s (primary failed): %s",
+            event.user_id,
+            event.message,
+        )
+        EVENTS_HANDLED_BY.append("fallback")
+
+
+# -----------------------------------------------------------------------------
+# Mappers and bootstrap
+# -----------------------------------------------------------------------------
+
+
+def command_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(SendNotificationCommand, SendNotificationCommandHandler)
+
+
+def events_mapper(mapper: cqrs.EventMap) -> None:
+    # Without circuit breaker: any exception from primary triggers fallback
+    mapper.bind(
+        NotificationSent,
+        cqrs.EventHandlerFallback(
+            primary=PrimaryNotificationSentHandler,
+            fallback=FallbackNotificationSentHandler,
+        ),
+    )
+
+
+def events_mapper_with_circuit_breaker(mapper: cqrs.EventMap) -> None:
+    try:
+        event_cb = AioBreakerAdapter(fail_max=2, timeout_duration=60)
+    except ImportError:
+        # No aiobreaker: use same as without circuit breaker
+        events_mapper(mapper)
+        return
+    mapper.bind(
+        NotificationSent,
+        cqrs.EventHandlerFallback(
+            primary=PrimaryNotificationSentHandler,
+            fallback=FallbackNotificationSentHandler,
+            circuit_breaker=event_cb,
+        ),
+    )
+
+
+async def main() -> None:
+    EVENTS_HANDLED_BY.clear()
+
+    use_circuit_breaker = False
+    try:
+        import aiobreaker  # noqa: F401
+
+        use_circuit_breaker = True
+    except ImportError:
+        pass
+
+    events_mapper_fn = events_mapper_with_circuit_breaker if use_circuit_breaker else events_mapper
+
+    mediator = bootstrap.bootstrap(
+        di_container=di.Container(),
+        commands_mapper=command_mapper,
+        domain_events_mapper=events_mapper_fn,
+    )
+
+    print("\n" + "=" * 60)
+    print("EVENT HANDLER FALLBACK EXAMPLE")
+    print("=" * 60)
+    print("\nSending command that emits NotificationSent...")
+    print("Primary handler will fail; fallback handler will run.\n")
+
+    await mediator.send(
+        SendNotificationCommand(user_id="user_1", message="Hello from CQRS"),
+    )
+
+    print("\nResult:")
+    print(f"  Handlers that ran (in order): {EVENTS_HANDLED_BY}")
+    assert "primary" in EVENTS_HANDLED_BY and "fallback" in EVENTS_HANDLED_BY
+    assert EVENTS_HANDLED_BY[-1] == "fallback"
+    print("  ✓ Primary ran and failed; fallback ran and completed.")
+    print("\n" + "=" * 60 + "\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/fastapi_sse_streaming.py b/examples/fastapi_sse_streaming.py
index 75b90de..5ee31d6 100644
--- a/examples/fastapi_sse_streaming.py
+++ b/examples/fastapi_sse_streaming.py
@@ -219,7 +219,7 @@ def clear_events(self) -> None:
         """Clear events after they have been processed and emitted."""
         self._events.clear()
 
-    async def handle(  # type: ignore[override]
+    async def handle(
         self,
         request: ProcessFilesCommand,
     ) -> typing.AsyncIterator[FileProcessedResult]:
@@ -230,8 +230,7 @@ async def handle(  # type: ignore[override]
         in parallel by different event handlers.
         """
         logger.info(
-            f"Starting to process {len(request.file_ids)} files "
-            f"with operation: {request.operation}",
+            f"Starting to process {len(request.file_ids)} files " f"with operation: {request.operation}",
         )
 
         for idx, file_id in enumerate(request.file_ids):
@@ -308,8 +307,7 @@ async def handle(self, event: FileProcessedEvent) -> None:
         """Log file processing."""
         await asyncio.sleep(0.05)  # Simulate processing
         logger.info(
-            f"📄 File {event.file_id} processed: "
-            f"{event.operation} ({event.file_size_mb} MB)",
+            f"📄 File {event.file_id} processed: " f"{event.operation} ({event.file_size_mb} MB)",
         )
 
 
@@ -320,8 +318,7 @@ async def handle(self, event: FileAnalyticsEvent) -> None:
         """Update analytics."""
         await asyncio.sleep(0.03)  # Simulate database update
         logger.info(
-            f"📊 Analytics updated for file {event.file_id}: "
-            f"{event.processing_time_ms}ms processing time",
+            f"📊 Analytics updated for file {event.file_id}: " f"{event.processing_time_ms}ms processing time",
         )
 
 
diff --git a/examples/kafka_event_consuming.py b/examples/kafka_event_consuming.py
index 2a0543b..b6f7a89 100644
--- a/examples/kafka_event_consuming.py
+++ b/examples/kafka_event_consuming.py
@@ -158,9 +158,7 @@ def mediator_factory() -> cqrs.EventMediator:
     decoder=empty_message_decoder,
 )
 async def hello_world_event_handler(
-    body: cqrs.NotificationEvent[HelloWorldPayload]
-    | deserializers.DeserializeJsonError
-    | None,
+    body: cqrs.NotificationEvent[HelloWorldPayload] | deserializers.DeserializeJsonError | None,
     msg: kafka.KafkaMessage,
     mediator: cqrs.EventMediator = faststream.Depends(mediator_factory),
 ):
@@ -177,6 +175,6 @@ async def hello_world_event_handler(
     )
     print(
         f"1. Run kafka infrastructure with: `docker compose -f ./docker-compose-dev.yml up -d`\n"
-        f"2. Send to kafka topic `hello_world` event: {orjson.dumps(ev.model_dump(mode='json')).decode()}",
+        f"2. Send to kafka topic `hello_world` event: {orjson.dumps(ev.to_dict()).decode()}",
     )
     asyncio.run(app.run())
diff --git a/examples/kafka_proto_event_consuming.py b/examples/kafka_proto_event_consuming.py
deleted file mode 100644
index 686a433..0000000
--- a/examples/kafka_proto_event_consuming.py
+++ /dev/null
@@ -1,163 +0,0 @@
-"""
-Example: Consuming Protobuf Events from Kafka
-
-This example demonstrates how to consume Protobuf-serialized events from Kafka
-and process them using CQRS event handlers. The system shows how to use Protobuf
-for efficient binary serialization in event-driven systems.
-
-Use case: High-throughput event processing with efficient serialization. Protobuf
-provides compact binary format, faster serialization/deserialization, and schema
-evolution support compared to JSON. This is ideal for systems processing large
-volumes of events.
-
-================================================================================
-HOW TO RUN THIS EXAMPLE
-================================================================================
-
-Step 1: Start Kafka Infrastructure
------------------------------------
-   docker compose -f ./docker-compose-dev.yml up -d
-
-Wait for Kafka to be ready (usually takes 30-60 seconds).
-
-Step 2: Send Protobuf Events to Kafka
---------------------------------------
-In a separate terminal, run the producer:
-   python examples/kafka_proto_event_producing.py
-
-This will send a Protobuf-serialized UserJoinedECST event to the "user_joined_proto" topic.
-
-Step 3: Run the Consumer
--------------------------
-   python examples/kafka_proto_event_consuming.py
-
-The consumer will:
-- Connect to Kafka broker at localhost:9092
-- Subscribe to "user_joined_proto" topic
-- Deserialize Protobuf messages into UserJoinedECST events
-- Process events through event handlers
-- Print event details for each received event
-
-================================================================================
-WHAT THIS EXAMPLE DEMONSTRATES
-================================================================================
-
-1. Protobuf Deserialization:
-   - Use ProtobufValueDeserializer to deserialize Kafka messages
-   - Deserialize binary Protobuf data into typed event objects
-   - Map Protobuf messages to domain event models
-
-2. Protobuf Schema Integration:
-   - Use generated Protobuf classes (UserJoinedECSTProtobuf)
-   - Convert Protobuf messages to domain events
-   - Handle schema evolution and versioning
-
-3. Event Handler Processing:
-   - Register event handlers for Protobuf events
-   - EventMediator dispatches events to handlers
-   - Handlers process events asynchronously
-
-4. Error Handling:
-   - Check for DeserializeProtobufError before processing
-   - Acknowledge messages only after successful processing
-   - Handle deserialization failures gracefully
-
-================================================================================
-REQUIREMENTS
-================================================================================
-
-Make sure you have installed:
-   - cqrs (this package)
-   - di (dependency injection)
-   - faststream (Kafka integration)
-   - protobuf (Protobuf support)
-
-Make sure Kafka is running:
-   - Use docker-compose-dev.yml to start Kafka locally
-   - Or configure connection to existing Kafka cluster
-
-For more information about Protobuf deserialization:
-   https://github.com/confluentinc/confluent-kafka-python/blob/master/examples/protobuf_consumer.py
-
-================================================================================
-"""
-
-import asyncio
-import logging
-
-import cqrs
-import di
-import faststream
-from cqrs.deserializers import protobuf
-from cqrs.events import bootstrap
-from faststream import kafka
-
-from examples import kafka_proto_event_producing
-from examples.proto.user_joined_pb2 import UserJoinedECST as UserJoinedECSTProtobuf  # type: ignore
-
-logging.basicConfig(level=logging.DEBUG)
-logging.getLogger("aiokafka").setLevel(logging.ERROR)
-logger = logging.getLogger("cqrs")
-
-broker = kafka.KafkaBroker(bootstrap_servers=["localhost:9092"])
-app = faststream.FastStream(broker, logger=logger)
-
-TOPIC_NAME = "user_joined_proto"
-
-
-class UserJoinedECSTEventHandler(
-    cqrs.EventHandler[kafka_proto_event_producing.UserJoinedECST],
-):
-    async def handle(
-        self,
-        event: kafka_proto_event_producing.UserJoinedECST,
-    ) -> None:
-        print(
-            f"Handle user {event.payload.user_id} joined meeting {event.payload.meeting_id} event",
-        )
-
-
-def events_mapper(mapper: cqrs.EventMap) -> None:
-    """Maps events to handlers."""
-    mapper.bind(
-        kafka_proto_event_producing.UserJoinedECST,
-        UserJoinedECSTEventHandler,
-    )
-
-
-def mediator_factory() -> cqrs.EventMediator:
-    return bootstrap.bootstrap(
-        di_container=di.Container(),
-        events_mapper=events_mapper,
-    )
-
-
-@broker.subscriber(
-    TOPIC_NAME,
-    group_id="protobuf_consumers",
-    auto_commit=False,
-    auto_offset_reset="earliest",
-    value_deserializer=protobuf.ProtobufValueDeserializer(
-        model=kafka_proto_event_producing.UserJoinedECST,
-        protobuf_model=UserJoinedECSTProtobuf,
-    ),
-)
-async def consumer(
-    body: kafka_proto_event_producing.UserJoinedECST
-    | protobuf.DeserializeProtobufError,
-    msg: kafka.KafkaMessage,
-    mediator: cqrs.EventMediator = faststream.Depends(mediator_factory),
-) -> None:
-    if not isinstance(body, protobuf.DeserializeProtobufError):
-        await mediator.send(body)
-    await msg.ack()
-
-
-if __name__ == "__main__":
-    # More information about deserialization:
-    # https://github.com/confluentinc/confluent-kafka-python/blob/master/examples/protobuf_consumer.py
-    print(
-        "1. Run kafka infrastructure with: `docker compose -f ./docker-compose-dev.yml up -d`\n"
-        "2. Send event to kafka topic via `python examples/kafka_proto_event_producing.py`",
-    )
-    asyncio.run(app.run())
diff --git a/examples/kafka_proto_event_producing.py b/examples/kafka_proto_event_producing.py
deleted file mode 100644
index 6c88f1d..0000000
--- a/examples/kafka_proto_event_producing.py
+++ /dev/null
@@ -1,163 +0,0 @@
-"""
-Example: Producing Protobuf Events to Kafka
-
-This example demonstrates how to produce Protobuf-serialized events to Kafka.
-The system shows how to use Protobuf for efficient binary serialization in
-event-driven systems.
-
-Use case: High-throughput event publishing with efficient serialization. Protobuf
-provides compact binary format, faster serialization/deserialization, and schema
-evolution support compared to JSON. This is ideal for systems publishing large
-volumes of events.
-
-================================================================================
-HOW TO RUN THIS EXAMPLE
-================================================================================
-
-Step 1: Start Kafka Infrastructure
------------------------------------
-   docker compose -f ./docker-compose-dev.yml up -d
-
-Wait for Kafka to be ready (usually takes 30-60 seconds).
-
-Step 2: Run the Producer
--------------------------
-   python examples/kafka_proto_event_producing.py
-
-The producer will:
-- Create a UserJoinedECST event with Protobuf payload
-- Convert the event to Protobuf format
-- Publish the event to Kafka topic "user_joined_proto"
-- Use Protobuf serialization for efficient binary encoding
-
-Step 3: Verify Event (Optional)
----------------------------------
-Run the consumer example to verify the event was published:
-   python examples/kafka_proto_event_consuming.py
-
-================================================================================
-WHAT THIS EXAMPLE DEMONSTRATES
-================================================================================
-
-1. Protobuf Event Definition:
-   - Create NotificationEvent with typed payloads (Pydantic models)
-   - Implement proto() method to convert events to Protobuf format
-   - Map domain events to Protobuf schema
-
-2. Protobuf Serialization:
-   - Configure Kafka producer with protobuf_value_serializer
-   - Serialize events to compact binary format
-   - Reduce message size compared to JSON
-
-3. Kafka Producer Configuration:
-   - Set up Kafka producer with connection settings
-   - Configure security protocols (PLAINTEXT or SASL_SSL)
-   - Support for SSL/TLS and SASL authentication
-
-4. Event Publishing:
-   - Create OutboxedEvent wrapper for publishing
-   - Send events to Kafka topics using message broker
-   - Events are serialized and published asynchronously
-
-================================================================================
-REQUIREMENTS
-================================================================================
-
-Make sure you have installed:
-   - cqrs (this package)
-   - pydantic (for typed payloads)
-   - protobuf (Protobuf support)
-
-Make sure Kafka is running:
-   - Use docker-compose-dev.yml to start Kafka locally
-   - Or configure connection to existing Kafka cluster
-
-For more information about Protobuf serialization:
-   https://github.com/confluentinc/confluent-kafka-python/blob/master/examples/protobuf_producer.py
-
-================================================================================
-"""
-
-import asyncio
-import ssl
-
-import pydantic
-
-import cqrs
-from cqrs.adapters import kafka as kafka_adapters
-from cqrs.message_brokers import kafka, protocol as broker_protocol
-from cqrs.outbox import repository
-from cqrs.serializers import protobuf
-from examples.proto.user_joined_pb2 import UserJoinedECST as UserJoinedECSTProtobuf  # type: ignore
-
-
-class UserJoinedECSTPayload(pydantic.BaseModel, frozen=True):
-    user_id: str
-    meeting_id: str
-
-    model_config = pydantic.ConfigDict(from_attributes=True)
-
-
-class UserJoinedECST(cqrs.NotificationEvent[UserJoinedECSTPayload], frozen=True):
-    def proto(self) -> UserJoinedECSTProtobuf:
-        return UserJoinedECSTProtobuf(
-            event_id=str(self.event_id),
-            event_timestamp=str(self.event_timestamp),
-            event_name=self.event_name,
-            payload=UserJoinedECSTProtobuf.Payload(
-                user_id=self.payload.user_id,  # type: ignore
-                meeting_id=self.payload.meeting_id,  # type: ignore
-            ),
-        )
-
-
-def create_kafka_producer(
-    ssl_context: ssl.SSLContext | None = None,
-) -> kafka_adapters.KafkaProducer:
-    dsn = "localhost:9092"
-    value_serializer = protobuf.protobuf_value_serializer
-    if ssl_context is None:
-        return kafka_adapters.kafka_producer_factory(
-            security_protocol="PLAINTEXT",
-            sasl_mechanism="PLAIN",
-            dsn=dsn,
-            value_serializer=value_serializer,
-        )
-    return kafka_adapters.kafka_producer_factory(
-        security_protocol="SASL_SSL",
-        sasl_mechanism="SCRAM-SHA-256",
-        ssl_context=ssl_context,
-        dsn=dsn,
-        value_serializer=value_serializer,
-    )
-
-
-async def main():
-    event = UserJoinedECST(
-        event_name="user_joined_ecst",
-        topic="user_joined_proto",
-        payload=UserJoinedECSTPayload(user_id="123", meeting_id="456"),
-    )
-    kafka_producer = create_kafka_producer(ssl_context=None)
-    broker = kafka.KafkaMessageBroker(
-        producer=kafka_producer,
-    )
-    await broker.send_message(
-        message=broker_protocol.Message(
-            message_name=event.event_name,
-            message_id=event.event_id,
-            topic=event.topic,
-            payload=repository.OutboxedEvent(
-                id=1,
-                event=event,
-                status=repository.EventStatus.NEW,
-                topic=event.topic,
-            ),
-        ),
-    )
-
-
-if __name__ == "__main__":
-    # More information about serialization:
-    # https://github.com/confluentinc/confluent-kafka-python/blob/master/examples/protobuf_producer.py
-    asyncio.run(main())
diff --git a/examples/request_fallback.py b/examples/request_fallback.py
new file mode 100644
index 0000000..2f5a63c
--- /dev/null
+++ b/examples/request_fallback.py
@@ -0,0 +1,213 @@
+"""
+Example: Request Handler Fallback with Optional Circuit Breaker
+
+This example demonstrates the RequestHandlerFallback pattern for command/query
+handlers. When the primary request handler fails (or the circuit breaker is
+open), the fallback handler is invoked. This is useful for resilient reads
+or writes when the primary path (e.g. database or external API) is unavailable.
+
+================================================================================
+HOW TO RUN THIS EXAMPLE
+================================================================================
+
+Run the example (without circuit breaker):
+   python examples/request_fallback.py
+
+With circuit breaker (optional dependency):
+   pip install aiobreaker
+   python examples/request_fallback.py
+
+The example will:
+- Send a command that is handled by a primary handler (simulated to fail)
+- Fallback handler runs and returns a valid response
+- With circuit breaker: after N failures the circuit opens and requests are
+  dispatched to fallback without calling the primary handler
+
+================================================================================
+WHAT THIS EXAMPLE DEMONSTRATES
+================================================================================
+
+1. RequestHandlerFallback Registration:
+   - Bind request type to RequestHandlerFallback(primary, fallback, ...)
+   - Optional failure_exceptions to trigger fallback only for specific errors
+   - Optional circuit_breaker (e.g. AioBreakerAdapter) per domain
+
+2. Primary and Fallback Handlers:
+   - Both implement RequestHandler[Request, Response]
+   - Primary can raise; fallback provides alternative implementation (e.g. cache)
+
+3. Flow:
+   - mediator.send(request) dispatches to primary handler
+   - On primary exception (or circuit open): fallback handler is invoked
+   - Response and events from the handler that ran are returned
+
+4. Circuit Breaker (optional):
+   - Use one AioBreakerAdapter instance per domain (e.g. commands)
+   - After fail_max failures, circuit opens; primary is not called, fallback runs
+
+================================================================================
+REQUIREMENTS
+================================================================================
+
+Make sure you have installed:
+   - cqrs (this package)
+   - di (dependency injection)
+
+Optional for circuit breaker:
+   pip install aiobreaker
+   or: pip install python-cqrs[aiobreaker]
+
+================================================================================
+"""
+
+import asyncio
+import logging
+import di
+
+import cqrs
+from cqrs.adapters.circuit_breaker import AioBreakerAdapter
+from cqrs.requests import bootstrap
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+HANDLER_USED: list[str] = []
+
+
+# -----------------------------------------------------------------------------
+# Command and response
+# -----------------------------------------------------------------------------
+
+
+class GetUserProfileCommand(cqrs.Request):
+    user_id: str
+
+
+class UserProfileResult(cqrs.Response):
+    user_id: str
+    name: str
+    source: str  # "primary" or "fallback"
+
+
+# -----------------------------------------------------------------------------
+# Primary handler (simulates failure – e.g. database unavailable)
+# -----------------------------------------------------------------------------
+
+
+class PrimaryGetUserProfileHandler(
+    cqrs.RequestHandler[GetUserProfileCommand, UserProfileResult],
+):
+    @property
+    def events(self) -> list[cqrs.Event]:
+        return []
+
+    async def handle(
+        self,
+        request: GetUserProfileCommand,
+    ) -> UserProfileResult:
+        logger.info("Primary handler: fetching profile for user %s", request.user_id)
+        HANDLER_USED.append("primary")
+        raise ConnectionError("Database unavailable")
+
+
+# -----------------------------------------------------------------------------
+# Fallback handler (e.g. return cached or default data)
+# -----------------------------------------------------------------------------
+
+
+class FallbackGetUserProfileHandler(
+    cqrs.RequestHandler[GetUserProfileCommand, UserProfileResult],
+):
+    @property
+    def events(self) -> list[cqrs.Event]:
+        return []
+
+    async def handle(
+        self,
+        request: GetUserProfileCommand,
+    ) -> UserProfileResult:
+        logger.info(
+            "Fallback handler: returning cached/default profile for user %s",
+            request.user_id,
+        )
+        HANDLER_USED.append("fallback")
+        return UserProfileResult(
+            user_id=request.user_id,
+            name="Unknown User",
+            source="fallback",
+        )
+
+
+# -----------------------------------------------------------------------------
+# Mappers and bootstrap
+# -----------------------------------------------------------------------------
+
+
+def commands_mapper(mapper: cqrs.RequestMap) -> None:
+    # Without circuit breaker: fallback on any exception (or restrict with failure_exceptions)
+    mapper.bind(
+        GetUserProfileCommand,
+        cqrs.RequestHandlerFallback(
+            primary=PrimaryGetUserProfileHandler,
+            fallback=FallbackGetUserProfileHandler,
+            failure_exceptions=(ConnectionError, TimeoutError),
+        ),
+    )
+
+
+def commands_mapper_with_circuit_breaker(mapper: cqrs.RequestMap) -> None:
+    try:
+        request_cb = AioBreakerAdapter(fail_max=2, timeout_duration=60)
+    except ImportError:
+        commands_mapper(mapper)
+        return
+    mapper.bind(
+        GetUserProfileCommand,
+        cqrs.RequestHandlerFallback(
+            primary=PrimaryGetUserProfileHandler,
+            fallback=FallbackGetUserProfileHandler,
+            failure_exceptions=(ConnectionError, TimeoutError),
+            circuit_breaker=request_cb,
+        ),
+    )
+
+
+async def main() -> None:
+    HANDLER_USED.clear()
+
+    use_circuit_breaker = False
+    try:
+        import aiobreaker  # noqa: F401
+
+        use_circuit_breaker = True
+    except ImportError:
+        pass
+
+    commands_mapper_fn = commands_mapper_with_circuit_breaker if use_circuit_breaker else commands_mapper
+
+    mediator = bootstrap.bootstrap(
+        di_container=di.Container(),
+        commands_mapper=commands_mapper_fn,
+    )
+
+    print("\n" + "=" * 60)
+    print("REQUEST HANDLER FALLBACK EXAMPLE")
+    print("=" * 60)
+    print("\nSending GetUserProfileCommand (primary will fail)...\n")
+
+    result: UserProfileResult = await mediator.send(
+        GetUserProfileCommand(user_id="user_42"),
+    )
+
+    print("\nResult:")
+    print(f"  Handlers that ran (in order): {HANDLER_USED}")
+    print(f"  Response: user_id={result.user_id}, name={result.name}, source={result.source}")
+    assert result.source == "fallback"
+    assert "primary" in HANDLER_USED and "fallback" in HANDLER_USED
+    assert HANDLER_USED[-1] == "fallback"
+    print("  ✓ Primary ran and failed; fallback ran and returned response.")
+    print("\n" + "=" * 60 + "\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/request_response_types.py b/examples/request_response_types.py
new file mode 100644
index 0000000..12b76b9
--- /dev/null
+++ b/examples/request_response_types.py
@@ -0,0 +1,386 @@
+"""
+Example: Different Request and Response Types
+
+This example demonstrates the flexibility of the CQRS library in supporting different
+types of Request and Response implementations. The library supports both Pydantic-based
+and Dataclass-based implementations, allowing you to choose the best fit for your needs.
+
+Use case: Flexibility in choosing request/response implementations. You can use:
+- PydanticRequest/PydanticResponse for validation and serialization features
+- DCRequest/DCResponse for lightweight implementations without Pydantic dependency
+- Mix and match different types based on your requirements
+
+================================================================================
+HOW TO RUN THIS EXAMPLE
+================================================================================
+
+Run the example:
+   python examples/request_response_types.py
+
+The example will:
+- Demonstrate Pydantic-based requests and responses
+- Demonstrate Dataclass-based requests and responses
+- Show mixed usage (Pydantic request with Dataclass response, etc.)
+- Verify that all types work correctly with the mediator
+
+================================================================================
+WHAT THIS EXAMPLE DEMONSTRATES
+================================================================================
+
+1. PydanticRequest and PydanticResponse:
+   - Use Pydantic models for automatic validation
+   - Benefit from Pydantic's serialization features
+   - Type-safe with runtime validation
+
+2. DCRequest and DCResponse:
+   - Use Python dataclasses for lightweight implementations
+   - No Pydantic dependency required
+   - Simple and straightforward
+
+3. Mixed Usage:
+   - Combine Pydantic requests with Dataclass responses
+   - Combine Dataclass requests with Pydantic responses
+   - Flexibility to choose the best type for each use case
+
+4. Type Compatibility:
+   - All request types implement IRequest interface
+   - All response types implement IResponse interface
+   - Mediator works seamlessly with all types
+
+================================================================================
+REQUIREMENTS
+================================================================================
+
+Make sure you have installed:
+   - cqrs (this package)
+   - di (dependency injection)
+   - pydantic (for PydanticRequest/PydanticResponse)
+
+================================================================================
+"""
+
+import asyncio
+import dataclasses
+import logging
+import typing
+
+import di
+import pydantic
+
+import cqrs
+from cqrs.requests import bootstrap
+
+logging.basicConfig(level=logging.INFO)
+
+# Storage for demonstration
+USER_STORAGE: typing.Dict[str, typing.Dict[str, typing.Any]] = {}
+PRODUCT_STORAGE: typing.Dict[str, typing.Dict[str, typing.Any]] = {}
+ORDER_STORAGE: typing.Dict[str, typing.Dict[str, typing.Any]] = {}
+
+# ============================================================================
+# Pydantic-based Request and Response
+# ============================================================================
+
+
+class CreateUserCommand(cqrs.PydanticRequest):
+    """Pydantic-based command with automatic validation."""
+
+    username: str
+    email: str
+    age: int = pydantic.Field(gt=0, le=120)
+
+
+class UserResponse(cqrs.PydanticResponse):
+    """Pydantic-based response with validation."""
+
+    user_id: str
+    username: str
+    email: str
+    age: int
+
+
+class CreateUserCommandHandler(cqrs.RequestHandler[CreateUserCommand, UserResponse]):
+    """Handler using Pydantic request and response."""
+
+    @property
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
+        return []
+
+    async def handle(self, request: CreateUserCommand) -> UserResponse:
+        user_id = f"user_{len(USER_STORAGE) + 1}"
+        user_data = {
+            "user_id": user_id,
+            "username": request.username,
+            "email": request.email,
+            "age": request.age,
+        }
+        USER_STORAGE[user_id] = user_data
+        print(f"Created user with Pydantic: {user_data}")
+        return UserResponse(**user_data)
+
+
+# ============================================================================
+# Dataclass-based Request and Response
+# ============================================================================
+
+
+@dataclasses.dataclass
+class CreateProductCommand(cqrs.DCRequest):
+    """Dataclass-based command - lightweight, no Pydantic dependency."""
+
+    name: str
+    price: float
+    category: str
+
+
+@dataclasses.dataclass
+class ProductResponse(cqrs.DCResponse):
+    """Dataclass-based response - simple and straightforward."""
+
+    product_id: str
+    name: str
+    price: float
+    category: str
+
+
+class CreateProductCommandHandler(
+    cqrs.RequestHandler[CreateProductCommand, ProductResponse],
+):
+    """Handler using Dataclass request and response."""
+
+    @property
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
+        return []
+
+    async def handle(self, request: CreateProductCommand) -> ProductResponse:
+        product_id = f"product_{len(PRODUCT_STORAGE) + 1}"
+        product_data = {
+            "product_id": product_id,
+            "name": request.name,
+            "price": request.price,
+            "category": request.category,
+        }
+        PRODUCT_STORAGE[product_id] = product_data
+        print(f"Created product with Dataclass: {product_data}")
+        return ProductResponse(**product_data)
+
+
+# ============================================================================
+# Mixed: Pydantic Request with Dataclass Response
+# ============================================================================
+
+
+class CreateOrderCommand(cqrs.PydanticRequest):
+    """Pydantic request with validation."""
+
+    user_id: str
+    product_id: str
+    quantity: int = pydantic.Field(gt=0)
+
+
+@dataclasses.dataclass
+class OrderResponse(cqrs.DCResponse):
+    """Dataclass response - lightweight."""
+
+    order_id: str
+    user_id: str
+    product_id: str
+    quantity: int
+    total_price: float
+
+
+class CreateOrderCommandHandler(
+    cqrs.RequestHandler[CreateOrderCommand, OrderResponse],
+):
+    """Handler mixing Pydantic request with Dataclass response."""
+
+    @property
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
+        return []
+
+    async def handle(self, request: CreateOrderCommand) -> OrderResponse:
+        if request.user_id not in USER_STORAGE:
+            raise ValueError(f"User {request.user_id} not found")
+        if request.product_id not in PRODUCT_STORAGE:
+            raise ValueError(f"Product {request.product_id} not found")
+
+        order_id = f"order_{len(ORDER_STORAGE) + 1}"
+        product = PRODUCT_STORAGE[request.product_id]
+        total_price = product["price"] * request.quantity
+
+        order_data = {
+            "order_id": order_id,
+            "user_id": request.user_id,
+            "product_id": request.product_id,
+            "quantity": request.quantity,
+            "total_price": total_price,
+        }
+        ORDER_STORAGE[order_id] = order_data
+        print(f"Created order (Pydantic request + Dataclass response): {order_data}")
+        return OrderResponse(**order_data)
+
+
+# ============================================================================
+# Mixed: Dataclass Request with Pydantic Response
+# ============================================================================
+
+
+@dataclasses.dataclass
+class GetUserQuery(cqrs.DCRequest):
+    """Dataclass query - simple and lightweight."""
+
+    user_id: str
+
+
+class UserDetailsResponse(cqrs.PydanticResponse):
+    """Pydantic response with validation."""
+
+    user_id: str
+    username: str
+    email: str
+    age: int
+    total_orders: int = 0
+
+
+class GetUserQueryHandler(
+    cqrs.RequestHandler[GetUserQuery, UserDetailsResponse],
+):
+    """Handler mixing Dataclass request with Pydantic response."""
+
+    @property
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
+        return []
+
+    async def handle(self, request: GetUserQuery) -> UserDetailsResponse:
+        if request.user_id not in USER_STORAGE:
+            raise ValueError(f"User {request.user_id} not found")
+
+        user = USER_STORAGE[request.user_id]
+        total_orders = sum(1 for order in ORDER_STORAGE.values() if order["user_id"] == request.user_id)
+
+        return UserDetailsResponse(
+            user_id=user["user_id"],
+            username=user["username"],
+            email=user["email"],
+            age=user["age"],
+            total_orders=total_orders,
+        )
+
+
+# ============================================================================
+# Mapping and Bootstrap
+# ============================================================================
+
+
+def commands_mapper(mapper: cqrs.RequestMap) -> None:
+    """Register all command handlers."""
+    mapper.bind(CreateUserCommand, CreateUserCommandHandler)
+    mapper.bind(CreateProductCommand, CreateProductCommandHandler)
+    mapper.bind(CreateOrderCommand, CreateOrderCommandHandler)
+
+
+def queries_mapper(mapper: cqrs.RequestMap) -> None:
+    """Register all query handlers."""
+    mapper.bind(GetUserQuery, GetUserQueryHandler)
+
+
+# ============================================================================
+# Main Execution
+# ============================================================================
+
+
+async def main():
+    """Demonstrate different request/response type combinations."""
+    mediator = bootstrap.bootstrap(
+        di_container=di.Container(),
+        commands_mapper=commands_mapper,
+        queries_mapper=queries_mapper,
+    )
+
+    print("=" * 80)
+    print("Demonstrating Different Request/Response Types")
+    print("=" * 80)
+    print()
+
+    # 1. Pydantic Request + Pydantic Response
+    print("1. Pydantic Request + Pydantic Response")
+    print("-" * 80)
+    user_response = await mediator.send(
+        CreateUserCommand(username="john_doe", email="john@example.com", age=30),
+    )
+    print(f"Response type: {type(user_response).__name__}")
+    print(f"Response data: {user_response.to_dict()}")
+    print()
+
+    # 2. Dataclass Request + Dataclass Response
+    print("2. Dataclass Request + Dataclass Response")
+    print("-" * 80)
+    product_response = await mediator.send(
+        CreateProductCommand(name="Laptop", price=999.99, category="Electronics"),
+    )
+    print(f"Response type: {type(product_response).__name__}")
+    print(f"Response data: {product_response.to_dict()}")
+    print()
+
+    # 3. Pydantic Request + Dataclass Response
+    print("3. Pydantic Request + Dataclass Response")
+    print("-" * 80)
+    order_response = await mediator.send(
+        CreateOrderCommand(
+            user_id=user_response.user_id,
+            product_id=product_response.product_id,
+            quantity=2,
+        ),
+    )
+    print(f"Response type: {type(order_response).__name__}")
+    print(f"Response data: {order_response.to_dict()}")
+    print()
+
+    # 4. Dataclass Request + Pydantic Response
+    print("4. Dataclass Request + Pydantic Response")
+    print("-" * 80)
+    user_details = await mediator.send(GetUserQuery(user_id=user_response.user_id))
+    print(f"Response type: {type(user_details).__name__}")
+    print(f"Response data: {user_details.to_dict()}")
+    print()
+
+    # Demonstrate serialization/deserialization
+    print("=" * 80)
+    print("Serialization/Deserialization Demo")
+    print("=" * 80)
+    print()
+
+    # Serialize Pydantic response
+    user_dict = user_response.to_dict()
+    print(f"Pydantic response serialized: {user_dict}")
+    restored_user = UserResponse.from_dict(**user_dict)
+    print(f"Pydantic response restored: {restored_user}")
+    print()
+
+    # Serialize Dataclass response
+    product_dict = product_response.to_dict()
+    print(f"Dataclass response serialized: {product_dict}")
+    restored_product = ProductResponse.from_dict(**product_dict)
+    print(f"Dataclass response restored: {restored_product}")
+    print()
+
+    # Validation example with Pydantic
+    print("=" * 80)
+    print("Pydantic Validation Example")
+    print("=" * 80)
+    try:
+        # This should fail validation (age > 120)
+        await mediator.send(
+            CreateUserCommand(username="invalid", email="test@example.com", age=150),
+        )
+    except pydantic.ValidationError as e:
+        print(f"Validation error caught (expected): {e}")
+    print()
+
+    print("=" * 80)
+    print("All examples completed successfully!")
+    print("=" * 80)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/saga.py b/examples/saga.py
index 52ae06c..417eb54 100644
--- a/examples/saga.py
+++ b/examples/saga.py
@@ -55,6 +55,8 @@
 
 4. Saga Storage and Logging:
    - SagaStorage persists saga state and execution history
+   - MemorySagaStorage and SqlAlchemySagaStorage support create_run(): execution
+     uses one session per saga and checkpoint commits (fewer commits, better performance)
    - Each step execution is logged (act/compensate, status, timestamp)
    - Storage enables recovery of interrupted sagas
    - Use storage.get_step_history() to view execution log
@@ -273,7 +275,20 @@ async def create_shipment(
         items: list[str],
         address: str,
     ) -> tuple[str, str]:
-        """Create a shipment for the order."""
+        """
+        Create a shipment for an order and record its tracking number.
+
+        Parameters:
+            order_id (str): Identifier of the order to ship.
+            items (list[str]): List of item identifiers included in the shipment.
+            address (str): Shipping address; must not be empty.
+
+        Returns:
+            tuple[str, str]: A tuple containing the created `shipment_id` and its `tracking_number`.
+
+        Raises:
+            ValueError: If `address` is empty.
+        """
         if not address:
             raise ValueError("Shipping address is required")
 
@@ -283,8 +298,7 @@ async def create_shipment(
 
         self._shipments[shipment_id] = tracking_number
         print(
-            f"  ✓ Created shipment {shipment_id} for order {order_id} "
-            f"(tracking: {tracking_number})",
+            f"  ✓ Created shipment {shipment_id} for order {order_id} " f"(tracking: {tracking_number})",
         )
         return shipment_id, tracking_number
 
@@ -468,7 +482,11 @@ class OrderSaga(Saga[OrderContext]):
 
 
 async def run_successful_saga() -> None:
-    """Demonstrate a successful saga execution."""
+    """
+    Run an example order-processing saga and print the per-step progress and final results.
+
+    Sets up mock services, dependency injection, and in-memory saga storage; executes the OrderSaga with a generated saga ID, prints each completed step, then prints the final saga status, context fields (inventory reservation, payment ID, shipment ID) and the persisted execution log. If saga execution fails, the failure is printed and the exception is re-raised.
+    """
     print("\n" + "=" * 70)
     print("SCENARIO 1: Successful Order Processing Saga")
     print("=" * 70)
@@ -478,8 +496,10 @@ async def run_successful_saga() -> None:
     payment_service = PaymentService()
     shipping_service = ShippingService()
 
-    # Create saga storage for persistence
-    # In production, use SQLAlchemySagaStorage or another persistent storage
+    # Create saga storage for persistence.
+    # MemorySagaStorage (and SqlAlchemySagaStorage) support create_run():
+    # execution uses one session per saga and checkpoint commits for better performance.
+    # In production, use SqlAlchemySagaStorage or another persistent storage.
     storage = MemorySagaStorage()
 
     # Setup DI container
diff --git a/examples/saga_fallback.py b/examples/saga_fallback.py
new file mode 100644
index 0000000..78a8fa9
--- /dev/null
+++ b/examples/saga_fallback.py
@@ -0,0 +1,436 @@
+"""
+Example: Saga Fallback Pattern with Circuit Breaker
+
+This example demonstrates how to configure a saga with fallback steps and
+circuit breaker protection. The fallback pattern allows defining alternative
+steps to execute when primary steps fail, while circuit breakers prevent
+cascading failures by opening the circuit when a service becomes unhealthy.
+
+================================================================================
+HOW TO RUN THIS EXAMPLE
+================================================================================
+
+Prerequisites:
+   pip install aiobreaker  # Required for circuit breaker functionality
+
+Run the example:
+   python examples/saga_fallback.py
+
+The example will demonstrate:
+- Primary step that always fails
+- Fallback step execution when primary fails
+- Circuit breaker opening after repeated failures
+- Primary step NOT executing when circuit breaker is open (fail fast)
+
+================================================================================
+WHAT THIS EXAMPLE DEMONSTRATES
+================================================================================
+
+1. Fallback Pattern Configuration:
+   - Define primary step handler that fails
+   - Define fallback step handler as alternative
+   - Wrap step with Fallback() to enable fallback behavior
+   - Automatic context snapshot/restore before fallback execution
+
+2. Circuit Breaker Integration:
+   - Use AioBreakerAdapter to protect steps from cascading failures
+   - Configure fail_max (failure threshold) and timeout_duration
+   - Circuit breaker opens after threshold failures
+
+3. Fallback Execution Flow:
+   - Primary step executes first and fails
+   - Fallback step executes automatically
+   - Context is restored from snapshot before fallback execution
+
+4. Circuit Breaker Protection:
+   - After threshold failures, circuit breaker opens
+   - When circuit is OPEN, PrimaryStep is NOT executed (fail fast)
+   - Fallback is NOT triggered for CircuitBreakerError
+   - This prevents unnecessary load on failing services
+
+================================================================================
+REQUIREMENTS
+================================================================================
+
+Make sure you have installed:
+   - cqrs (this package)
+   - aiobreaker (for circuit breaker functionality)
+   - pydantic (for context models)
+   - di (for dependency injection)
+
+Install circuit breaker dependency:
+   pip install aiobreaker
+
+Or install with optional dependencies:
+   pip install python-cqrs[aiobreaker]
+
+================================================================================
+"""
+
+import asyncio
+import dataclasses
+import logging
+import uuid
+
+import di
+from di import dependent
+
+import cqrs
+from cqrs.adapters.circuit_breaker import AioBreakerAdapter
+from cqrs.events.event import Event
+from cqrs.response import Response
+from cqrs.saga import bootstrap
+from cqrs.saga.fallback import Fallback
+from cqrs.saga.models import SagaContext
+from cqrs.saga.saga import Saga
+from cqrs.saga.step import SagaStepHandler, SagaStepResult
+from cqrs.saga.storage.memory import MemorySagaStorage
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Domain Models
+# ============================================================================
+
+
+@dataclasses.dataclass
+class OrderContext(SagaContext):
+    """Shared context passed between all saga steps."""
+
+    order_id: str
+    user_id: str
+    amount: float
+
+    # This field is populated by step during execution
+    reservation_id: str | None = None
+
+
+# ============================================================================
+# Step Responses
+# ============================================================================
+
+
+class ReserveInventoryResponse(Response):
+    """Response from inventory reservation step."""
+
+    reservation_id: str
+    source: str  # "primary" or "fallback"
+
+
+# ============================================================================
+# Saga Step Handlers
+# ============================================================================
+
+
+class PrimaryStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+    """Primary step that always fails."""
+
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+        self._call_count = 0  # Track how many times act() was called
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    @property
+    def call_count(self) -> int:
+        """Get number of times act() was called."""
+        return self._call_count
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        """
+        Simulate a failing primary reservation step for the saga.
+
+        This action always raises a RuntimeError to emulate an unavailable downstream service and trigger fallback or compensation behavior.
+
+        Parameters:
+            context (OrderContext): Shared saga context containing order details (e.g., order_id, user_id, amount, reservation_id).
+
+        Raises:
+            RuntimeError: Indicates the primary step failed (service unavailable).
+        """
+        self._call_count += 1
+        logger.info(
+            f"  [PrimaryStep] Executing act() for order {context.order_id} " f"(call #{self._call_count})...",
+        )
+        raise RuntimeError("Primary step failed - service unavailable")
+
+    async def compensate(self, context: OrderContext) -> None:
+        """Compensation for primary step."""
+        logger.info(f"  Compensating primary step for order {context.order_id}")
+
+
+class FallbackStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+    """Fallback step that succeeds."""
+
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        """Fallback step that succeeds."""
+        logger.info(f"  Executing fallback step for order {context.order_id}...")
+        reservation_id = f"fallback_reservation_{context.order_id}"
+
+        # Update context
+        context.reservation_id = reservation_id
+
+        response = ReserveInventoryResponse(
+            reservation_id=reservation_id,
+            source="fallback",
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        """Compensation for fallback step."""
+        logger.info(f"  Compensating fallback step for order {context.order_id}")
+
+
+# ============================================================================
+# Saga Class Definition with Fallback
+# ============================================================================
+
+
+class OrderSagaWithFallback(Saga[OrderContext]):
+    """Order processing saga with fallback step and circuit breaker protection."""
+
+    steps = [
+        Fallback(
+            step=PrimaryStep,
+            fallback=FallbackStep,
+            circuit_breaker=AioBreakerAdapter(
+                fail_max=2,  # Circuit opens after 2 failures
+                timeout_duration=60,  # Wait 60 seconds before retry
+            ),
+        ),
+    ]
+
+
+# ============================================================================
+# Main Example
+# ============================================================================
+
+
+async def run_saga(
+    mediator: cqrs.SagaMediator,
+    storage: MemorySagaStorage,
+    order_id: str,
+    primary_step: PrimaryStep,
+) -> None:
+    """Run a single saga execution."""
+    saga_id = uuid.uuid4()
+    context = OrderContext(
+        order_id=order_id,
+        user_id="user_123",
+        amount=100.0,
+    )
+
+    print(f"\nProcessing order {order_id} (saga_id: {saga_id})...")
+    initial_call_count = primary_step.call_count
+
+    try:
+        step_results = []
+        async for step_result in mediator.stream(context, saga_id=saga_id):
+            step_results.append(step_result)
+            step_name = step_result.step_type.__name__
+            if hasattr(step_result.response, "source"):
+                source = getattr(step_result.response, "source", "N/A")
+                print(f"  ✓ Step completed: {step_name} (source: {source})")
+            else:
+                print(f"  ✓ Step completed: {step_name}")
+
+        print("  ✓ Saga completed successfully")
+        print(
+            f"  - PrimaryStep.act() was called: {primary_step.call_count - initial_call_count} time(s)",
+        )
+
+    except Exception as e:
+        # Check if it's a CircuitBreakerError
+        try:
+            from aiobreaker import CircuitBreakerError
+
+            is_circuit_breaker_error = isinstance(e, CircuitBreakerError)
+        except ImportError:
+            # Fallback: check by error message/type name
+            is_circuit_breaker_error = "CircuitBreakerError" in str(type(e).__name__)
+
+        if is_circuit_breaker_error:
+            print("  ✗ CircuitBreakerError: Circuit is OPEN")
+            print(
+                f"  - PrimaryStep.act() was called: {primary_step.call_count - initial_call_count} time(s)",
+            )
+            print("  - PrimaryStep was NOT executed (fail fast)")
+            print("  - Fallback was NOT triggered")
+        else:
+            print(f"  ✗ Saga failed: {e}")
+            print(
+                f"  - PrimaryStep.act() was called: {primary_step.call_count - initial_call_count} time(s)",
+            )
+
+
+async def main() -> None:
+    """
+    Run an interactive demonstration of the saga fallback pattern with a circuit breaker.
+
+    Executes three scenarios that show a failing primary step with an automatic fallback, the circuit breaker opening after a configurable number of failures, and fail-fast behavior when the circuit is open. Also conditionally demonstrates configuring a Redis-backed circuit breaker storage, prints per-scenario results and a summary, and informs about missing optional dependencies.
+    """
+    print("\n" + "=" * 80)
+    print("SAGA FALLBACK PATTERN WITH CIRCUIT BREAKER EXAMPLE")
+    print("=" * 80)
+    print("\nThis example demonstrates:")
+    print("  • Primary step that always fails")
+    print("  • Automatic fallback step execution")
+    print("  • Circuit breaker opening after 2 failures")
+    print("  • Primary step NOT executing when circuit breaker is open")
+
+    # Setup DI container
+    di_container = di.Container()
+
+    # Register step handlers (create instances to track call count)
+    primary_step = PrimaryStep()
+    fallback_step = FallbackStep()
+
+    di_container.bind(
+        di.bind_by_type(
+            dependent.Dependent(lambda: primary_step, scope="request"),
+            PrimaryStep,
+        ),
+    )
+    di_container.bind(
+        di.bind_by_type(
+            dependent.Dependent(lambda: fallback_step, scope="request"),
+            FallbackStep,
+        ),
+    )
+
+    # Create saga storage (supports create_run(): one session per saga, checkpoint commits)
+    storage = MemorySagaStorage()
+    di_container.bind(
+        di.bind_by_type(
+            dependent.Dependent(lambda: storage, scope="request"),
+            MemorySagaStorage,
+        ),
+    )
+
+    # Define saga mapper
+    def saga_mapper(mapper: cqrs.SagaMap) -> None:
+        mapper.bind(OrderContext, OrderSagaWithFallback)
+
+    # Create saga mediator using bootstrap
+    mediator = bootstrap.bootstrap(
+        di_container=di_container,
+        sagas_mapper=saga_mapper,
+        saga_storage=storage,
+    )
+
+    print("\n" + "=" * 80)
+    print("SCENARIO 1: First execution (PrimaryStep fails, FallbackStep succeeds)")
+    print("=" * 80)
+    await run_saga(mediator, storage, "order_001", primary_step)
+
+    print("\n" + "=" * 80)
+    print(
+        "SCENARIO 2: Second execution (PrimaryStep fails again, FallbackStep succeeds)",
+    )
+    print("=" * 80)
+    print("  (After 2 failures, circuit breaker will open)")
+    await run_saga(mediator, storage, "order_002", primary_step)
+
+    print("\n" + "=" * 80)
+    print("SCENARIO 3: Third execution (Circuit breaker is OPEN)")
+    print("=" * 80)
+    print("  (PrimaryStep will NOT be executed - fail fast)")
+    await run_saga(mediator, storage, "order_003", primary_step)
+
+    # ------------------------------------------------------------------------
+    # DEMO: Redis Storage Configuration (Optional)
+    # ------------------------------------------------------------------------
+    print("\n" + "=" * 80)
+    print("DEMO: Configuring Circuit Breaker with Redis Storage")
+    print("=" * 80)
+
+    try:
+        import redis
+        from aiobreaker.storage.redis import CircuitRedisStorage
+        from aiobreaker import CircuitBreakerState
+
+        # Factory function to create Redis storage
+        def redis_storage_factory(name: str):
+            # Note: decode_responses=False is important for aiobreaker compatibility
+            client = redis.from_url(
+                "redis://localhost:6379",
+                encoding="utf-8",
+                decode_responses=False,
+            )
+            return CircuitRedisStorage(
+                state=CircuitBreakerState.CLOSED,
+                redis_object=client,
+                namespace=name,
+            )
+
+        # Example configuration with Redis storage
+        class OrderSagaWithRedisBreaker(Saga[OrderContext]):
+            steps = [
+                Fallback(
+                    step=PrimaryStep,
+                    fallback=FallbackStep,
+                    circuit_breaker=AioBreakerAdapter(
+                        fail_max=2,
+                        timeout_duration=60,
+                        storage_factory=redis_storage_factory,
+                    ),
+                ),
+            ]
+
+        print("✓ Successfully defined Saga with Redis-backed Circuit Breaker")
+        print("  (Use this pattern to share circuit state across multiple instances)")
+
+    except ImportError:
+        print("ℹ️ Redis dependencies not installed. Skipping Redis demo.")
+        print("  To use Redis storage, install: pip install redis")
+
+    print("\n" + "=" * 80)
+    print("✅ EXAMPLE COMPLETED")
+    print("=" * 80)
+    print("\nSummary:")
+    print(f"  • Total PrimaryStep.act() calls: {primary_step.call_count}")
+    print(
+        "  • First 2 executions: PrimaryStep executed and failed, FallbackStep succeeded",
+    )
+    print("  • Third execution: PrimaryStep NOT executed (circuit breaker OPEN)")
+    print("  • Circuit breaker prevents unnecessary load on failing service")
+    print("\nKey Takeaways:")
+    print("  • Circuit breaker opens after threshold failures")
+    print("  • When circuit is OPEN, PrimaryStep is NOT executed (fail fast)")
+    print("  • Fallback is NOT triggered for CircuitBreakerError")
+    print("  • This prevents cascading failures and unnecessary load")
+    print("\n" + "=" * 80 + "\n")
+
+    try:
+        import aiobreaker  # noqa: F401
+    except ImportError:
+        print("\n" + "=" * 80)
+        print("❌ MISSING DEPENDENCY")
+        print("=" * 80)
+        print("\naiobreaker is required for circuit breaker functionality.")
+        print("\nInstall it with:")
+        print("  pip install aiobreaker")
+        print("\nOr install with optional dependencies:")
+        print("  pip install python-cqrs[aiobreaker]")
+        print("\n" + "=" * 80 + "\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/saga_fastapi_sse.py b/examples/saga_fastapi_sse.py
index 08fe7fd..8cb8b86 100644
--- a/examples/saga_fastapi_sse.py
+++ b/examples/saga_fastapi_sse.py
@@ -89,6 +89,8 @@
    - Saga state and execution history are persisted to SagaStorage
 
 3. Saga Storage and Logging:
+   - MemorySagaStorage/SqlAlchemySagaStorage support create_run(): one session per saga,
+     checkpoint commits (fewer commits, better performance)
    - SagaStorage persists saga state and execution history
    - Each step execution is logged (act/compensate, status, timestamp)
    - Storage enables recovery of interrupted sagas
@@ -291,7 +293,7 @@ def __init__(self, inventory_service: InventoryService) -> None:
         self._events: list[cqrs.Event] = []
 
     @property
-    def events(self) -> list[cqrs.Event]:
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
         return self._events.copy()
 
     async def act(
@@ -325,7 +327,7 @@ def __init__(self, payment_service: PaymentService) -> None:
         self._events: list[cqrs.Event] = []
 
     @property
-    def events(self) -> list[cqrs.Event]:
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
         return self._events.copy()
 
     async def act(
@@ -356,7 +358,7 @@ def __init__(self, shipping_service: ShippingService) -> None:
         self._events: list[cqrs.Event] = []
 
     @property
-    def events(self) -> list[cqrs.Event]:
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
         return self._events.copy()
 
     async def act(
@@ -400,7 +402,7 @@ class OrderSaga(Saga[OrderContext]):
 # DI Container Setup
 # ============================================================================
 
-# Shared storage instance (in production, use persistent storage)
+# Shared storage (MemorySagaStorage uses create_run(): scoped run, checkpoint commits)
 saga_storage = MemorySagaStorage()
 
 # Setup DI container
@@ -449,9 +451,7 @@ def mediator_factory() -> cqrs.SagaMediator:
 def serialize_response(response: Response | None) -> dict[str, typing.Any]:
     if response is None:
         return {}
-    if isinstance(response, pydantic.BaseModel):
-        return response.model_dump()
-    return {"response": str(response)}
+    return response.to_dict()
 
 
 @app.post("/process-order")
diff --git a/examples/saga_mermaid.py b/examples/saga_mermaid.py
index d20cdc6..84252f7 100644
--- a/examples/saga_mermaid.py
+++ b/examples/saga_mermaid.py
@@ -61,6 +61,7 @@
 from cqrs import container as cqrs_container
 from cqrs.events.event import Event
 from cqrs.response import Response
+from cqrs.saga.fallback import Fallback
 from cqrs.saga.mermaid import SagaMermaid
 from cqrs.saga.models import SagaContext
 from cqrs.saga.saga import Saga
@@ -218,6 +219,52 @@ class OrderSaga(Saga[OrderContext]):
     ]
 
 
+# ============================================================================
+# Fallback Example: Saga with Fallback Step
+# ============================================================================
+
+
+class ReserveInventoryFallbackStep(
+    SagaStepHandler[OrderContext, ReserveInventoryResponse],
+):
+    """Fallback step: Reserve inventory using alternative service."""
+
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        """Reserve inventory using fallback service."""
+        response = ReserveInventoryResponse(
+            reservation_id=f"fallback_reservation_{context.order_id}",
+            items_reserved=context.items,
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        """Release reserved items from fallback service."""
+        pass
+
+
+class OrderSagaWithFallback(Saga[OrderContext]):
+    """Order processing saga with Fallback step for inventory reservation."""
+
+    steps = [
+        Fallback(
+            step=ReserveInventoryStep,
+            fallback=ReserveInventoryFallbackStep,
+        ),
+        ProcessPaymentStep,
+        ShipOrderStep,
+    ]
+
+
 # ============================================================================
 # Simple Container (for example purposes)
 # ============================================================================
@@ -283,10 +330,12 @@ def main() -> None:
     print("\nThis example demonstrates how to generate Mermaid diagrams")
     print("from Saga instances for documentation and visualization purposes.")
 
-    # Create saga instance (steps are defined as class attribute)
-    saga = OrderSaga()
+    # Example 1: Regular Saga
+    print("\n" + "=" * 80)
+    print("EXAMPLE 1: Regular Saga (without Fallback)")
+    print("=" * 80)
 
-    # Create Mermaid generator
+    saga = OrderSaga()
     generator = SagaMermaid(saga)
 
     # Generate Sequence Diagram
@@ -303,14 +352,44 @@ def main() -> None:
     class_diagram = generator.class_diagram()
     print_diagram("CLASS DIAGRAM - Saga Type Structure", class_diagram, "Class")
 
+    # Example 2: Saga with Fallback
+    print("\n" + "=" * 80)
+    print("EXAMPLE 2: Saga with Fallback Step")
+    print("=" * 80)
+    print("\nThis example shows how Fallback steps are visualized in Mermaid diagrams.")
+    print("The Fallback wrapper includes both primary and fallback step handlers.")
+
+    saga_with_fallback = OrderSagaWithFallback()
+    generator_fallback = SagaMermaid(saga_with_fallback)
+
+    # Generate Sequence Diagram with Fallback
+    print("\n📊 Generating Sequence Diagram with Fallback...")
+    sequence_diagram_fallback = generator_fallback.sequence()
+    print_diagram(
+        "SEQUENCE DIAGRAM - Saga with Fallback Execution Flow",
+        sequence_diagram_fallback,
+        "Sequence",
+    )
+
+    # Generate Class Diagram with Fallback
+    print("\n📊 Generating Class Diagram with Fallback...")
+    class_diagram_fallback = generator_fallback.class_diagram()
+    print_diagram(
+        "CLASS DIAGRAM - Saga with Fallback Type Structure",
+        class_diagram_fallback,
+        "Class",
+    )
+
     print("\n" + "=" * 80)
     print("✅ EXAMPLE COMPLETED SUCCESSFULLY")
     print("=" * 80)
-    print("\nBoth diagrams have been generated and are ready to use!")
+    print("\nAll diagrams have been generated and are ready to use!")
     print("\nQuick start:")
     print("  • Copy the code blocks above (they include ```mermaid markers)")
     print("  • Paste into https://mermaid.live/ to view rendered diagrams")
     print("  • Or use directly in markdown files with Mermaid support")
+    print("\n💡 Note: Fallback steps show both primary and fallback handlers")
+    print("   in the diagrams, demonstrating the fallback execution flow.")
     print("\n" + "=" * 80 + "\n")
 
 
diff --git a/examples/saga_recovery.py b/examples/saga_recovery.py
index 2bd4e77..a7848be 100644
--- a/examples/saga_recovery.py
+++ b/examples/saga_recovery.py
@@ -57,6 +57,8 @@
 ================================================================================
 
 1. Saga State Persistence:
+   - MemorySagaStorage/SqlAlchemySagaStorage use create_run(): one session per saga,
+     checkpoint commits after each step (fewer commits, better performance)
    - Saga state is saved to storage after each step
    - Storage tracks which steps completed successfully
    - Context data is persisted for recovery
@@ -279,7 +281,20 @@ async def create_shipment(
         items: list[str],
         address: str,
     ) -> tuple[str, str]:
-        """Create a shipment for the order."""
+        """
+        Create a shipment record for the given order and generate a tracking number.
+
+        Parameters:
+            order_id (str): Identifier of the order.
+            items (list[str]): Items included in the shipment.
+            address (str): Destination shipping address.
+
+        Returns:
+            tuple[str, str]: A tuple containing the shipment ID and the tracking number.
+
+        Raises:
+            ValueError: If `address` is empty.
+        """
         if not address:
             raise ValueError("Shipping address is required")
 
@@ -289,8 +304,7 @@ async def create_shipment(
 
         self._shipments[shipment_id] = tracking_number
         logger.info(
-            f"  ✓ Created shipment {shipment_id} for order {order_id} "
-            f"(tracking: {tracking_number})",
+            f"  ✓ Created shipment {shipment_id} for order {order_id} " f"(tracking: {tracking_number})",
         )
         return shipment_id, tracking_number
 
@@ -518,23 +532,19 @@ async def resolve(self, type_: type) -> typing.Any:
 
 async def simulate_interrupted_saga() -> tuple[uuid.UUID, MemorySagaStorage]:
     """
-    Simulate a saga that gets interrupted after the first step.
-
-    This simulates what happens when:
-    - Server crashes after completing ReserveInventoryStep
-    - Network timeout occurs
-    - Process is killed during execution
-    - Database connection is lost
+    Simulate a saga that is interrupted after the inventory reservation step to produce a recoverable persisted state.
 
     Returns:
-        Tuple of (saga_id, storage) so we can recover it later.
+        tuple:
+            saga_id (uuid.UUID): Identifier of the created saga.
+            storage (MemorySagaStorage): In-memory storage containing the persisted saga state and step history for recovery.
     """
     print("\n" + "=" * 70)
     print("SCENARIO 1: Simulating Interrupted Saga")
     print("=" * 70)
     print("\nSimulating server crash after first step...")
 
-    # Setup services and storage
+    # Setup services and storage (MemorySagaStorage uses create_run(): scoped run, checkpoint commits)
     inventory_service = InventoryService()
     payment_service = PaymentService()
     shipping_service = ShippingService()
@@ -604,8 +614,7 @@ async def simulate_interrupted_saga() -> tuple[uuid.UUID, MemorySagaStorage]:
     print("\n  Execution log (SagaLog) before recovery:")
     for entry in history:
         print(
-            f"    [{entry.timestamp.strftime('%H:%M:%S')}] "
-            f"{entry.step_name}.{entry.action}: {entry.status.value}",
+            f"    [{entry.timestamp.strftime('%H:%M:%S')}] " f"{entry.step_name}.{entry.action}: {entry.status.value}",
         )
 
     print("\n⚠️  Problem: Order is incomplete!")
@@ -622,13 +631,13 @@ async def recover_interrupted_saga(
     storage: MemorySagaStorage,
 ) -> None:
     """
-    Recover and complete the interrupted saga.
+    Recover and complete an interrupted saga using persisted state.
+
+    Loads the saga state from storage, reconstructs the saga context, resumes execution from the last completed step, and completes any remaining steps to restore eventual consistency.
 
-    This demonstrates how recovery ensures eventual consistency by:
-    1. Loading saga state from storage
-    2. Reconstructing context
-    3. Resuming execution from last completed step
-    4. Completing remaining steps
+    Parameters:
+        saga_id (uuid.UUID): Identifier of the saga instance to recover.
+        storage (MemorySagaStorage): Durable storage containing the saga's persisted state and step history.
     """
     print("\n" + "=" * 70)
     print("SCENARIO 2: Recovering Interrupted Saga")
@@ -676,8 +685,7 @@ async def recover_interrupted_saga(
     print("\n  Execution log (SagaLog):")
     for entry in history:
         print(
-            f"    [{entry.timestamp.strftime('%H:%M:%S')}] "
-            f"{entry.step_name}.{entry.action}: {entry.status.value}",
+            f"    [{entry.timestamp.strftime('%H:%M:%S')}] " f"{entry.step_name}.{entry.action}: {entry.status.value}",
         )
 
     print("\n✅ System is now in consistent state!")
@@ -689,17 +697,19 @@ async def recover_interrupted_saga(
 
 async def simulate_interrupted_compensation() -> tuple[uuid.UUID, MemorySagaStorage]:
     """
-    Simulate a saga that fails and gets interrupted during compensation.
+    Simulate a saga that fails and is interrupted during compensation.
 
-    This shows recovery of compensation logic, which is critical for
-    maintaining consistency when rollback is interrupted.
+    Sets up services, a saga, and a failing shipment step to trigger compensation that is then artificially interrupted; returns identifiers and storage state for performing recovery in a separate run.
+
+    Returns:
+        tuple[uuid.UUID, MemorySagaStorage]: The saga ID and the in-memory storage containing the persisted saga state and step history after the simulated interruption.
     """
     print("\n" + "=" * 70)
     print("SCENARIO 3: Simulating Interrupted Compensation")
     print("=" * 70)
     print("\nSimulating failure during compensation...")
 
-    # Setup services
+    # Setup services and storage (scoped run via create_run() when supported)
     inventory_service = InventoryService()
     payment_service = PaymentService()
     shipping_service = ShippingService()
@@ -786,8 +796,7 @@ async def resolve_with_failing_step(type_: type) -> typing.Any:
     print("\n  Execution log (SagaLog) before recovery:")
     for entry in history:
         print(
-            f"    [{entry.timestamp.strftime('%H:%M:%S')}] "
-            f"{entry.step_name}.{entry.action}: {entry.status.value}",
+            f"    [{entry.timestamp.strftime('%H:%M:%S')}] " f"{entry.step_name}.{entry.action}: {entry.status.value}",
         )
 
     print("\n⚠️  Problem: Compensation incomplete!")
@@ -803,10 +812,13 @@ async def recover_interrupted_compensation(
     storage: MemorySagaStorage,
 ) -> None:
     """
-    Recover and complete the interrupted compensation.
+    Recover and complete an interrupted compensation for a saga.
+
+    Loads the saga state from the provided storage using the given saga identifier and drives any incomplete compensation steps to completion, ensuring resources (inventory, payments, shipments) are released and the system reaches a consistent state. Progress and final status are printed to stdout.
 
-    This ensures that even if compensation is interrupted, it will
-    eventually complete, releasing all resources.
+    Parameters:
+        saga_id (uuid.UUID): Identifier of the saga to recover.
+        storage (MemorySagaStorage): Persistent storage containing the saga state and step history.
     """
     print("\n" + "=" * 70)
     print("SCENARIO 4: Recovering Interrupted Compensation")
@@ -852,8 +864,7 @@ async def recover_interrupted_compensation(
     print("\n  Execution log (SagaLog):")
     for entry in history:
         print(
-            f"    [{entry.timestamp.strftime('%H:%M:%S')}] "
-            f"{entry.step_name}.{entry.action}: {entry.status.value}",
+            f"    [{entry.timestamp.strftime('%H:%M:%S')}] " f"{entry.step_name}.{entry.action}: {entry.status.value}",
         )
 
     print("\n✅ System is now in consistent state!")
diff --git a/examples/saga_recovery_scheduler.py b/examples/saga_recovery_scheduler.py
new file mode 100644
index 0000000..16d6d5e
--- /dev/null
+++ b/examples/saga_recovery_scheduler.py
@@ -0,0 +1,667 @@
+"""
+Example: Saga Recovery Scheduler (while + sleep)
+
+This example demonstrates how to run a simple recovery scheduler that periodically
+scans for stuck or failed sagas and recovers them. The scheduler uses a plain
+while loop with asyncio.sleep, suitable for a dedicated worker process or
+a background task.
+
+PROBLEM: Recovering Failed Sagas in Production
+=============================================
+
+When sagas run in production, processes can crash, time out, or be restarted.
+Incomplete sagas (RUNNING, COMPENSATING, FAILED) must be recovered so that:
+- Forward execution can complete
+- Compensation can finish
+- The system reaches eventual consistency
+
+A recovery job must:
+1. Find sagas that need recovery (not currently being executed)
+2. Avoid picking the same saga twice (e.g. limit by recovery_attempts)
+3. Run periodically without blocking the main application
+
+SOLUTION: While Loop + get_sagas_for_recovery
+=============================================
+
+Use get_sagas_for_recovery(limit=..., max_recovery_attempts=..., stale_after_seconds=...)
+to select only "stale" sagas (updated_at older than threshold), then call
+recover_saga for each. On recovery failure, recover_saga calls
+increment_recovery_attempts under the hood so the saga can be retried or
+excluded later; callers only need to call recover_saga.
+
+================================================================================
+HOW TO RUN THIS EXAMPLE
+================================================================================
+
+Run the example:
+   python examples/saga_recovery_scheduler.py
+
+The example will:
+- Create an in-memory storage and one interrupted saga (simulated crash)
+- Run the recovery scheduler loop for a few iterations
+- Recover the interrupted saga on the first iteration
+- Show that subsequent iterations find no sagas to recover
+
+================================================================================
+WHAT THIS EXAMPLE DEMONSTRATES
+================================================================================
+
+1. Recovery scheduler loop:
+   - while True with asyncio.sleep(interval_seconds)
+   - get_sagas_for_recovery(limit, max_recovery_attempts, stale_after_seconds)
+   - Per-saga recover_saga() only; increment_recovery_attempts is done inside recover_saga on failure
+   - When storage supports create_run() (e.g. MemorySagaStorage, SqlAlchemySagaStorage),
+     saga execution uses one session per saga and checkpoint commits
+
+2. Staleness filter (stale_after_seconds):
+   - Only sagas not updated recently are considered (avoids recovering
+     sagas that are currently being executed by another worker)
+
+3. Max recovery attempts:
+   - Sagas that fail recovery too many times are excluded from selection
+   - After increment_recovery_attempts, they can be retried until max is reached
+
+================================================================================
+REQUIREMENTS
+================================================================================
+
+Make sure you have installed:
+   - cqrs (this package)
+   - pydantic (for context models)
+
+This example declares its own domain model (OrderContext), step handlers,
+services, saga (OrderSaga), and container; it does not depend on other examples.
+
+================================================================================
+"""
+
+import asyncio
+import dataclasses
+import datetime
+import logging
+import typing
+import uuid
+
+from cqrs import container as cqrs_container
+from cqrs.events.event import Event
+from cqrs.response import Response
+from cqrs.saga.models import SagaContext
+from cqrs.saga.recovery import recover_saga
+from cqrs.saga.saga import Saga
+from cqrs.saga.step import SagaStepHandler, SagaStepResult
+from cqrs.saga.storage.enums import SagaStatus, SagaStepStatus
+from cqrs.saga.storage.memory import MemorySagaStorage
+from cqrs.saga.storage.protocol import ISagaStorage
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Domain Models
+# ============================================================================
+
+
+@dataclasses.dataclass
+class OrderContext(SagaContext):
+    """Shared context passed between all saga steps."""
+
+    order_id: str
+    user_id: str
+    items: list[str]
+    total_amount: float
+    shipping_address: str
+
+    inventory_reservation_id: str | None = None
+    payment_id: str | None = None
+    shipment_id: str | None = None
+
+
+# ============================================================================
+# Step Responses
+# ============================================================================
+
+
+class ReserveInventoryResponse(Response):
+    """Response from inventory reservation step."""
+
+    reservation_id: str
+    items_reserved: list[str]
+
+
+class ProcessPaymentResponse(Response):
+    """Response from payment processing step."""
+
+    payment_id: str
+    amount_charged: float
+    transaction_id: str
+
+
+class ShipOrderResponse(Response):
+    """Response from shipping step."""
+
+    shipment_id: str
+    tracking_number: str
+    estimated_delivery: str
+
+
+# ============================================================================
+# Domain Events (minimal for step handlers)
+# ============================================================================
+
+
+class InventoryReservedEvent(Event, frozen=True):
+    """Event emitted when inventory is reserved."""
+
+    order_id: str
+    reservation_id: str
+    items: list[str]
+
+
+class PaymentProcessedEvent(Event, frozen=True):
+    """Event emitted when payment is processed."""
+
+    order_id: str
+    payment_id: str
+    amount: float
+
+
+class OrderShippedEvent(Event, frozen=True):
+    """Event emitted when order is shipped."""
+
+    order_id: str
+    shipment_id: str
+    tracking_number: str
+
+
+# ============================================================================
+# Mock Services
+# ============================================================================
+
+
+class InventoryService:
+    """Mock inventory service for reserving and releasing items."""
+
+    def __init__(self) -> None:
+        self._reservations: dict[str, list[str]] = {}
+        self._available_items: dict[str, int] = {
+            "item_1": 10,
+            "item_2": 5,
+            "item_3": 8,
+        }
+
+    async def reserve_items(self, order_id: str, items: list[str]) -> str:
+        reservation_id = f"reservation_{order_id}"
+        reserved_items = []
+        for item_id in items:
+            if item_id not in self._available_items:
+                raise ValueError(f"Item {item_id} not found")
+            if self._available_items[item_id] <= 0:
+                raise ValueError(f"Insufficient inventory for {item_id}")
+            self._available_items[item_id] -= 1
+            reserved_items.append(item_id)
+        self._reservations[reservation_id] = reserved_items
+        logger.info("  ✓ Reserved items %s for order %s", reserved_items, order_id)
+        return reservation_id
+
+    async def release_items(self, reservation_id: str) -> None:
+        if reservation_id not in self._reservations:
+            return
+        items = self._reservations[reservation_id]
+        for item_id in items:
+            self._available_items[item_id] += 1
+        del self._reservations[reservation_id]
+        logger.info("  ↻ Released items %s from reservation %s", items, reservation_id)
+
+
+class PaymentService:
+    """Mock payment service for processing payments and refunds."""
+
+    def __init__(self) -> None:
+        self._payments: dict[str, float] = {}
+        self._transaction_counter = 0
+
+    async def charge(self, order_id: str, amount: float) -> tuple[str, str]:
+        if amount <= 0:
+            raise ValueError("Payment amount must be positive")
+        self._transaction_counter += 1
+        payment_id = f"payment_{order_id}"
+        transaction_id = f"txn_{self._transaction_counter:06d}"
+        self._payments[payment_id] = amount
+        logger.info(
+            "  ✓ Charged $%.2f for order %s (transaction: %s)",
+            amount,
+            order_id,
+            transaction_id,
+        )
+        return payment_id, transaction_id
+
+    async def refund(self, payment_id: str) -> None:
+        if payment_id not in self._payments:
+            return
+        amount = self._payments[payment_id]
+        del self._payments[payment_id]
+        logger.info("  ↻ Refunded $%.2f for payment %s", amount, payment_id)
+
+
+class ShippingService:
+    """Mock shipping service for creating shipments."""
+
+    def __init__(self) -> None:
+        self._shipments: dict[str, str] = {}
+        self._tracking_counter = 0
+
+    async def create_shipment(
+        self,
+        order_id: str,
+        items: list[str],
+        address: str,
+    ) -> tuple[str, str]:
+        if not address:
+            raise ValueError("Shipping address is required")
+        self._tracking_counter += 1
+        shipment_id = f"shipment_{order_id}"
+        tracking_number = f"TRACK{self._tracking_counter:08d}"
+        self._shipments[shipment_id] = tracking_number
+        logger.info(
+            "  ✓ Created shipment %s for order %s (tracking: %s)",
+            shipment_id,
+            order_id,
+            tracking_number,
+        )
+        return shipment_id, tracking_number
+
+    async def cancel_shipment(self, shipment_id: str) -> None:
+        if shipment_id not in self._shipments:
+            return
+        tracking_number = self._shipments[shipment_id]
+        del self._shipments[shipment_id]
+        logger.info(
+            "  ↻ Cancelled shipment %s (tracking: %s)",
+            shipment_id,
+            tracking_number,
+        )
+
+
+# ============================================================================
+# Saga Step Handlers
+# ============================================================================
+
+
+class ReserveInventoryStep(
+    SagaStepHandler[OrderContext, ReserveInventoryResponse],
+):
+    """Step 1: Reserve inventory items for the order."""
+
+    def __init__(self, inventory_service: InventoryService) -> None:
+        self._inventory_service = inventory_service
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        reservation_id = await self._inventory_service.reserve_items(
+            order_id=context.order_id,
+            items=context.items,
+        )
+        context.inventory_reservation_id = reservation_id
+        self._events.append(
+            InventoryReservedEvent(
+                order_id=context.order_id,
+                reservation_id=reservation_id,
+                items=context.items,
+            ),
+        )
+        response = ReserveInventoryResponse(
+            reservation_id=reservation_id,
+            items_reserved=context.items,
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        if context.inventory_reservation_id:
+            await self._inventory_service.release_items(
+                context.inventory_reservation_id,
+            )
+
+
+class ProcessPaymentStep(
+    SagaStepHandler[OrderContext, ProcessPaymentResponse],
+):
+    """Step 2: Process payment for the order."""
+
+    def __init__(self, payment_service: PaymentService) -> None:
+        self._payment_service = payment_service
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ProcessPaymentResponse]:
+        payment_id, transaction_id = await self._payment_service.charge(
+            order_id=context.order_id,
+            amount=context.total_amount,
+        )
+        context.payment_id = payment_id
+        self._events.append(
+            PaymentProcessedEvent(
+                order_id=context.order_id,
+                payment_id=payment_id,
+                amount=context.total_amount,
+            ),
+        )
+        response = ProcessPaymentResponse(
+            payment_id=payment_id,
+            amount_charged=context.total_amount,
+            transaction_id=transaction_id,
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        if context.payment_id:
+            await self._payment_service.refund(context.payment_id)
+
+
+class ShipOrderStep(SagaStepHandler[OrderContext, ShipOrderResponse]):
+    """Step 3: Create shipment for the order."""
+
+    def __init__(self, shipping_service: ShippingService) -> None:
+        self._shipping_service = shipping_service
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ShipOrderResponse]:
+        shipment_id, tracking_number = await self._shipping_service.create_shipment(
+            order_id=context.order_id,
+            items=context.items,
+            address=context.shipping_address,
+        )
+        context.shipment_id = shipment_id
+        self._events.append(
+            OrderShippedEvent(
+                order_id=context.order_id,
+                shipment_id=shipment_id,
+                tracking_number=tracking_number,
+            ),
+        )
+        response = ShipOrderResponse(
+            shipment_id=shipment_id,
+            tracking_number=tracking_number,
+            estimated_delivery="2024-12-25",
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        if context.shipment_id:
+            await self._shipping_service.cancel_shipment(context.shipment_id)
+
+
+# ============================================================================
+# Saga Definition
+# ============================================================================
+
+
+class OrderSaga(Saga[OrderContext]):
+    """Order processing saga with three steps."""
+
+    steps = [
+        ReserveInventoryStep,
+        ProcessPaymentStep,
+        ShipOrderStep,
+    ]
+
+
+# ============================================================================
+# Container
+# ============================================================================
+
+
+class SimpleContainer(cqrs_container.Container[typing.Any]):
+    """Simple container for resolving step handlers."""
+
+    def __init__(
+        self,
+        inventory_service: InventoryService,
+        payment_service: PaymentService,
+        shipping_service: ShippingService,
+    ) -> None:
+        self._services = {
+            InventoryService: inventory_service,
+            PaymentService: payment_service,
+            ShippingService: shipping_service,
+        }
+        self._external_container: typing.Any = None
+
+    @property
+    def external_container(self) -> typing.Any:
+        return self._external_container
+
+    def attach_external_container(self, container: typing.Any) -> None:
+        self._external_container = container
+
+    async def resolve(self, type_: type) -> typing.Any:
+        if type_ in self._services:
+            return self._services[type_]
+        if type_ == ReserveInventoryStep:
+            return ReserveInventoryStep(self._services[InventoryService])
+        if type_ == ProcessPaymentStep:
+            return ProcessPaymentStep(self._services[PaymentService])
+        if type_ == ShipOrderStep:
+            return ShipOrderStep(self._services[ShippingService])
+        raise ValueError(f"Unknown type: {type_}")
+
+
+# ============================================================================
+# Scheduler configuration
+# ============================================================================
+
+RECOVERY_INTERVAL_SECONDS = 2
+RECOVERY_BATCH_LIMIT = 10
+MAX_RECOVERY_ATTEMPTS = 5
+STALE_AFTER_SECONDS = 60
+
+
+# ============================================================================
+# Recovery scheduler
+# ============================================================================
+
+
+def make_container() -> SimpleContainer:
+    """Create a fresh container with services (e.g. after process restart)."""
+    return SimpleContainer(
+        inventory_service=InventoryService(),
+        payment_service=PaymentService(),
+        shipping_service=ShippingService(),
+    )
+
+
+async def run_recovery_iteration(
+    storage: ISagaStorage,
+    saga: OrderSaga,
+    context_builder: typing.Type[OrderContext],
+) -> int:
+    """
+    Run one recovery iteration: fetch stale sagas, recover each.
+
+    recover_saga() increments recovery_attempts on failure under the hood;
+    the caller only calls recover_saga().
+
+    Returns the number of sagas processed (recovered or failed).
+    """
+    ids = await storage.get_sagas_for_recovery(
+        limit=RECOVERY_BATCH_LIMIT,
+        max_recovery_attempts=MAX_RECOVERY_ATTEMPTS,
+        stale_after_seconds=STALE_AFTER_SECONDS,
+    )
+    if not ids:
+        return 0
+
+    container = make_container()
+    processed = 0
+    for saga_id in ids:
+        try:
+            logger.info(f"Recovering saga {saga_id}...")
+            await recover_saga(saga, saga_id, context_builder, container, storage)
+            logger.info(f"Saga {saga_id} recovered successfully.")
+            processed += 1
+        except RuntimeError as e:
+            if "recovered in" in str(e) and "state" in str(e):
+                logger.info("Saga %s recovery completed compensation", saga_id)
+                processed += 1
+            else:
+                logger.exception("Saga %s recovery failed", saga_id)
+                processed += 1
+        except Exception:
+            logger.exception("Saga %s recovery failed", saga_id)
+            processed += 1
+    return processed
+
+
+async def recovery_loop(
+    storage: ISagaStorage,
+    *,
+    interval_seconds: float = RECOVERY_INTERVAL_SECONDS,
+    max_iterations: int | None = None,
+) -> None:
+    """
+    Run the recovery scheduler loop.
+
+    Args:
+        storage: Saga storage (e.g. MemorySagaStorage or SqlAlchemySagaStorage).
+        interval_seconds: Sleep duration between iterations.
+        max_iterations: If set, stop after this many iterations (for demo).
+                        None = run until cancelled.
+    """
+    saga = OrderSaga()
+    iteration = 0
+    while True:
+        iteration += 1
+        logger.info(f"Recovery iteration {iteration}")
+        try:
+            processed = await run_recovery_iteration(
+                storage,
+                saga,
+                OrderContext,
+            )
+            if processed > 0:
+                logger.info(f"Processed {processed} saga(s) this iteration.")
+            else:
+                logger.debug("No sagas to recover.")
+        except asyncio.CancelledError:
+            logger.info("Recovery loop cancelled.")
+            raise
+        except Exception:
+            logger.exception("Recovery iteration failed")
+
+        if max_iterations is not None and iteration >= max_iterations:
+            logger.info(f"Reached max_iterations={max_iterations}, stopping.")
+            break
+        await asyncio.sleep(interval_seconds)
+
+
+# ============================================================================
+# Demo: create one interrupted saga, then run scheduler
+# ============================================================================
+
+
+async def create_interrupted_saga(storage: MemorySagaStorage) -> uuid.UUID:
+    """
+    Create one saga in RUNNING state (simulating crash after first step).
+    Returns without recovering.
+    """
+    saga_id = uuid.uuid4()
+    context = OrderContext(
+        order_id="order_scheduler_demo",
+        user_id="user_1",
+        items=["item_1"],
+        total_amount=99.99,
+        shipping_address="123 Main St",
+    )
+
+    await storage.create_saga(
+        saga_id=saga_id,
+        name="order_saga",
+        context=context.to_dict(),
+    )
+    await storage.update_status(saga_id, SagaStatus.RUNNING)
+    await storage.log_step(
+        saga_id,
+        "ReserveInventoryStep",
+        "act",
+        SagaStepStatus.STARTED,
+    )
+    await storage.log_step(
+        saga_id,
+        "ReserveInventoryStep",
+        "act",
+        SagaStepStatus.COMPLETED,
+    )
+    ctx_dict = context.to_dict()
+    ctx_dict["inventory_reservation_id"] = "reservation_order_scheduler_demo"
+    await storage.update_context(saga_id, ctx_dict)
+
+    logger.info("Created interrupted saga %s (RUNNING, one step done).", saga_id)
+    return saga_id
+
+
+async def main() -> None:
+    """
+    Run the saga recovery scheduler demo and display its outcome.
+
+    Sets up an in-memory saga storage, creates a simulated interrupted saga and marks it stale, runs the recovery loop for three iterations (using the module's recovery_loop and recovery configuration constants), then loads and prints the final saga state.
+    """
+    print("\n" + "=" * 70)
+    print("SAGA RECOVERY SCHEDULER EXAMPLE")
+    print("=" * 70)
+    print("\nThis example demonstrates:")
+    print("  1. A simple while-loop recovery scheduler with asyncio.sleep")
+    print(
+        "  2. get_sagas_for_recovery(limit, max_recovery_attempts, stale_after_seconds)",
+    )
+    print(
+        "  3. recover_saga() per saga (increment_recovery_attempts on failure is internal)",
+    )
+
+    storage = MemorySagaStorage()  # supports create_run(): scoped run when executing sagas
+
+    saga_id = await create_interrupted_saga(storage)
+    storage._sagas[saga_id]["updated_at"] = datetime.datetime.now(
+        datetime.timezone.utc,
+    ) - datetime.timedelta(seconds=STALE_AFTER_SECONDS + 10)
+
+    print("\nRunning recovery loop for 3 iterations (interval=2s)...")
+    print("  Iteration 1 should recover the interrupted saga.")
+    print("  Iteration 2 and 3 should find no sagas.\n")
+
+    await recovery_loop(
+        storage,
+        interval_seconds=RECOVERY_INTERVAL_SECONDS,
+        max_iterations=3,
+    )
+
+    status, context_data, _ = await storage.load_saga_state(saga_id)
+    print("\n" + "-" * 70)
+    print(f"Final state of saga {saga_id}:")
+    print(f"  Status: {status}")
+    print("-" * 70)
+    print("\nEXAMPLE COMPLETED")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/saga_sqlalchemy_storage.py b/examples/saga_sqlalchemy_storage.py
index 5380edb..0260fa9 100644
--- a/examples/saga_sqlalchemy_storage.py
+++ b/examples/saga_sqlalchemy_storage.py
@@ -8,8 +8,9 @@
 Key features demonstrated:
 1. Configuring SQLAlchemy async engine with connection pooling
 2. Initializing SqlAlchemySagaStorage with a session factory
-3. Executing sagas with persistent state in a database (SQLite in this example)
-4. Handling transaction management automatically via the storage
+3. Executing sagas with persistent state in a database (SQLite/MySQL in this example)
+4. Scoped run: storage.create_run() is used automatically—one session per saga,
+   checkpoint commits after each step (fewer commits and sessions than the legacy path)
 
 Requirements:
     pip install sqlalchemy[asyncio] aiosqlite
@@ -39,8 +40,8 @@
 logger = logging.getLogger(__name__)
 
 # Database Configuration
-# Using SQLite for this example, but can be swapped for PostgreSQL/MySQL
-DB_URL = os.getenv("DATABASE_URL", "mysql+asyncmy://cqrs:cqrs@localhost:3307/test_cqrs")
+# Using SQLite for this example, but can be swapped for PostgreSQL/MySQL via DATABASE_URL
+DB_URL = os.getenv("DATABASE_URL", "sqlite+aiosqlite:///./test.db")
 
 
 # ============================================================================
@@ -139,6 +140,11 @@ async def setup_database(engine: AsyncEngine) -> None:
 
 
 async def main() -> None:
+    """
+    Run a demonstration that executes an OrderSaga using an async SQLAlchemy engine and persistent SqlAlchemySagaStorage.
+
+    Initializes a pooled async SQLAlchemy engine and schema, creates a session factory and SqlAlchemySagaStorage, bootstraps a mediator with a DI container and saga mapper, runs an OrderSaga while streaming step results to stdout, and then reloads and prints the persisted saga state and step history before disposing the engine.
+    """
     # 1. Create SQLAlchemy Engine with Connection Pool
     # SQLAlchemy creates a pool by default (QueuePool for most dialects, SingletonThreadPool for SQLite)
     engine = create_async_engine(
@@ -153,11 +159,12 @@ async def main() -> None:
         await setup_database(engine)
 
         # 3. Create Session Factory
-        # This factory will be used by the storage to create short-lived sessions for each operation
+        # Used by the storage; when the saga runs, create_run() yields one session per saga
+        # with checkpoint commits (after each step), reducing round-trips vs legacy path.
         session_factory = async_sessionmaker(engine, expire_on_commit=False)
 
         # 4. Initialize SqlAlchemySagaStorage
-        # We pass the session factory, allowing the storage to manage its own transactions
+        # Supports create_run(): execution uses one session per saga and checkpoint commits.
         saga_storage = SqlAlchemySagaStorage(session_factory)
 
         # 5. Setup Dependency Injection
diff --git a/examples/streaming_handler_fallback.py b/examples/streaming_handler_fallback.py
new file mode 100644
index 0000000..0820319
--- /dev/null
+++ b/examples/streaming_handler_fallback.py
@@ -0,0 +1,193 @@
+"""
+Example: Streaming Request Handler Fallback
+
+This example demonstrates RequestHandlerFallback with StreamingRequestHandler.
+When the primary streaming handler fails (e.g. raises after yielding some items),
+the fallback streaming handler is used and its stream is consumed.
+
+Use case: Stream results from a primary source (e.g. live API); if the stream
+fails mid-way, switch to a fallback stream (e.g. cached or degraded results).
+
+================================================================================
+HOW TO RUN THIS EXAMPLE
+================================================================================
+
+Run the example:
+   python examples/streaming_handler_fallback.py
+
+The example will:
+- Start streaming from the primary handler (yields a few items then raises)
+- After the exception, the fallback streaming handler runs and yields items
+- Collect and print all results from both handlers
+
+================================================================================
+WHAT THIS EXAMPLE DEMONSTRATES
+================================================================================
+
+1. RequestHandlerFallback with streaming handlers:
+   - primary and fallback are both StreamingRequestHandler (async generators).
+   - Dispatcher runs primary.handle(request); if it raises, runs fallback.handle(request).
+
+2. Flow:
+   - mediator.stream(request) yields results from the primary handler.
+   - When the primary raises, the dispatcher catches and continues with the
+     fallback handler's stream.
+
+3. Optional failure_exceptions and circuit_breaker:
+   - Same as for non-streaming RequestHandlerFallback.
+
+================================================================================
+REQUIREMENTS
+================================================================================
+
+Make sure you have installed:
+   - cqrs (this package)
+   - di (dependency injection)
+
+================================================================================
+"""
+
+from collections.abc import AsyncIterator
+
+import asyncio
+import logging
+import typing
+
+import di
+
+import cqrs
+from cqrs.requests import bootstrap
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+STREAM_SOURCE: list[str] = []  # "primary" or "fallback" per yield
+
+
+# -----------------------------------------------------------------------------
+# Request and response (streaming)
+# -----------------------------------------------------------------------------
+
+
+class StreamItemsCommand(cqrs.Request):
+    item_ids: list[str]
+
+
+class StreamItemResult(cqrs.Response):
+    item_id: str
+    status: str
+    source: str  # "primary" or "fallback"
+
+
+# -----------------------------------------------------------------------------
+# Primary streaming handler (yields twice then raises)
+# -----------------------------------------------------------------------------
+
+
+class PrimaryStreamItemsHandler(
+    cqrs.StreamingRequestHandler[StreamItemsCommand, StreamItemResult],
+):
+    def __init__(self) -> None:
+        self._events: list[cqrs.Event] = []
+
+    @property
+    def events(self) -> list[cqrs.Event]:
+        return self._events.copy()
+
+    def clear_events(self) -> None:
+        self._events.clear()
+
+    async def handle(
+        self,
+        request: StreamItemsCommand,
+    ) -> AsyncIterator[StreamItemResult]:
+        for i, item_id in enumerate(request.item_ids):
+            if i >= 2:
+                logger.info("Primary streaming handler raising after 2 items")
+                raise ConnectionError("Stream connection lost")
+            STREAM_SOURCE.append("primary")
+            yield StreamItemResult(
+                item_id=item_id,
+                status="processed",
+                source="primary",
+            )
+
+
+# -----------------------------------------------------------------------------
+# Fallback streaming handler (yields all items)
+# -----------------------------------------------------------------------------
+
+
+class FallbackStreamItemsHandler(
+    cqrs.StreamingRequestHandler[StreamItemsCommand, StreamItemResult],
+):
+    def __init__(self) -> None:
+        self._events: list[cqrs.Event] = []
+
+    @property
+    def events(self) -> list[cqrs.Event]:
+        return self._events.copy()
+
+    def clear_events(self) -> None:
+        self._events.clear()
+
+    async def handle(
+        self,
+        request: StreamItemsCommand,
+    ) -> AsyncIterator[StreamItemResult]:
+        for item_id in request.item_ids:
+            STREAM_SOURCE.append("fallback")
+            yield StreamItemResult(
+                item_id=item_id,
+                status="from_fallback",
+                source="fallback",
+            )
+
+
+# -----------------------------------------------------------------------------
+# Mapper and bootstrap
+# -----------------------------------------------------------------------------
+
+
+def commands_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(
+        StreamItemsCommand,
+        cqrs.RequestHandlerFallback(
+            primary=PrimaryStreamItemsHandler,
+            fallback=FallbackStreamItemsHandler,
+            failure_exceptions=(ConnectionError, TimeoutError),
+        ),
+    )
+
+
+async def main() -> None:
+    STREAM_SOURCE.clear()
+
+    mediator = bootstrap.bootstrap_streaming(
+        di_container=di.Container(),
+        commands_mapper=commands_mapper,
+    )
+
+    print("\n" + "=" * 60)
+    print("STREAMING HANDLER FALLBACK EXAMPLE")
+    print("=" * 60)
+    print("\nStreaming items (primary will fail after 2 items, then fallback runs)...\n")
+
+    request = StreamItemsCommand(item_ids=["id1", "id2", "id3", "id4"])
+    results: list[StreamItemResult] = []
+    async for response in mediator.stream(request):
+        if response is not None:
+            r = typing.cast(StreamItemResult, response)
+            results.append(r)
+            print(f"  Yield: item_id={r.item_id}, status={r.status}, source={r.source}")
+
+    print("\n   Handlers that yielded (in order): " + str(STREAM_SOURCE))
+    assert "primary" in STREAM_SOURCE and "fallback" in STREAM_SOURCE
+    assert results[0].source == "primary" and results[1].source == "primary"
+    assert any(r.source == "fallback" for r in results)
+    print("\n  ✓ Primary stream failed; fallback stream completed.")
+    print("=" * 60 + "\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/examples/streaming_handler_parallel_events.py b/examples/streaming_handler_parallel_events.py
index af028a1..b7cc68a 100644
--- a/examples/streaming_handler_parallel_events.py
+++ b/examples/streaming_handler_parallel_events.py
@@ -136,9 +136,7 @@ class InventoryUpdateEvent(cqrs.DomainEvent, frozen=True):
     """Event for inventory updates."""
 
     order_id: str
-    items: list[
-        dict[str, typing.Union[str, int]]
-    ]  # [{"product_id": "prod1", "quantity": 2}]
+    items: list[dict[str, typing.Union[str, int]]]  # [{"product_id": "prod1", "quantity": 2}]
 
 
 class AuditLogEvent(cqrs.DomainEvent, frozen=True):
@@ -177,10 +175,10 @@ def clear_events(self) -> None:
         """Clear events after they have been processed and emitted."""
         self._events.clear()
 
-    async def handle(  # type: ignore[override]
+    async def handle(
         self,
         request: ProcessOrdersCommand,
-    ) -> typing.AsyncIterator[OrderProcessedResult]:  # type: ignore[override]
+    ) -> typing.AsyncIterator[OrderProcessedResult]:
         """
         Process orders one by one, yielding results after each order.
 
@@ -198,9 +196,7 @@ async def handle(  # type: ignore[override]
                 "order_id": order_id,
                 "customer_id": f"customer_{order_id[-1]}",
                 "total_amount": 100.0 + float(order_id[-1]) * 10,
-                "items": [
-                    {"product_id": f"prod_{i}", "quantity": i + 1} for i in range(3)
-                ],
+                "items": [{"product_id": f"prod_{i}", "quantity": i + 1} for i in range(3)],
                 "category": "electronics" if int(order_id[-1]) % 2 == 0 else "clothing",
             }
 
@@ -238,8 +234,7 @@ async def handle(  # type: ignore[override]
                 InventoryUpdateEvent(
                     order_id=order_id,
                     items=[
-                        {"product_id": item["product_id"], "quantity": item["quantity"]}
-                        for item in order_data["items"]
+                        {"product_id": item["product_id"], "quantity": item["quantity"]} for item in order_data["items"]
                     ],
                 ),
             )
@@ -285,8 +280,7 @@ async def handle(self, event: OrderProcessedEvent) -> None:
 
         EMAIL_SENT_LOG.append(email_data)
         logger.info(
-            f"📧 Email sent for order {event.order_id} "
-            f"to customer {event.customer_id}",
+            f"📧 Email sent for order {event.order_id} " f"to customer {event.customer_id}",
         )
 
 
@@ -307,8 +301,7 @@ async def handle(self, event: OrderAnalyticsEvent) -> None:
         ANALYTICS_STORAGE["total_orders"] += 1
 
         logger.info(
-            f"📊 Analytics updated for order {event.order_id} "
-            f"in category {event.category}",
+            f"📊 Analytics updated for order {event.order_id} " f"in category {event.category}",
         )
 
 
@@ -330,8 +323,7 @@ async def handle(self, event: InventoryUpdateEvent) -> None:
             INVENTORY_STORAGE[product_id] -= quantity
 
         logger.info(
-            f"📦 Inventory updated for order {event.order_id}, "
-            f"items: {len(event.items)}",
+            f"📦 Inventory updated for order {event.order_id}, " f"items: {len(event.items)}",
         )
 
 
@@ -428,6 +420,10 @@ async def main():
     end_time = datetime.now()
     processing_time = (end_time - start_time).total_seconds()
 
+    # Allow fire-and-forget parallel event handlers to finish (EventProcessor
+    # uses create_task when concurrent_event_handle_enable=True and does not await)
+    await asyncio.sleep(0.3)
+
     # Print summary
     logger.info("\n" + "=" * 80)
     logger.info("Processing Summary")
@@ -449,15 +445,11 @@ async def main():
     logger.info("Example completed successfully!")
     logger.info("=" * 80)
 
-    # Verify results
-    # Note: Events are processed twice (once by dispatcher, once by emitter),
-    # so we expect double the counts
+    # Verify results: one event-handler invocation per order per handler type
     assert len(results) == len(order_ids)
-    assert len(EMAIL_SENT_LOG) == len(order_ids) * 2  # Each event handler called twice
-    assert len(AUDIT_LOG) == len(order_ids) * 2  # Each event handler called twice
-    assert (
-        ANALYTICS_STORAGE["total_orders"] == len(order_ids) * 2
-    )  # Each event handler called twice
+    assert len(EMAIL_SENT_LOG) == len(order_ids)
+    assert len(AUDIT_LOG) == len(order_ids)
+    assert ANALYTICS_STORAGE["total_orders"] == len(order_ids)
 
 
 if __name__ == "__main__":
diff --git a/pyproject.toml b/pyproject.toml
index 2a09a6d..9896e07 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -9,62 +9,69 @@ authors = [
 ]
 classifiers = [
   "Development Status :: 4 - Beta",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
-  "Programming Language :: Python :: 3.12",
-  "License :: OSI Approved :: MIT License",
-  "Operating System :: OS Independent"
+  "Programming Language :: Python :: 3.12"
 ]
 dependencies = [
+  "dataclass-wizard==0.*",
+  "di[anyio]==0.*",
+  "dependency-injector>=4.0",
+  "orjson==3.*",
   "pydantic==2.*",
-  "orjson==3.9.15",
-  "di[anyio]==0.79.2",
   "sqlalchemy[asyncio]==2.0.*",
-  "retry-async==0.1.4",
-  "python-dotenv==1.0.1",
-  "dependency-injector>=4.48.2"
+  "python-dotenv==1.*",
+  "retry-async==0.1.*",
+  "typing-extensions>=4.0"
 ]
-description = "Python CQRS pattern implementation"
+description = "Event-Driven Architecture Framework for Distributed Systems"
 maintainers = [{name = "Vadim Kozyrevskiy", email = "vadikko2@mail.ru"}]
 name = "python-cqrs"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "4.4.5"
+version = "4.10.1"
 
 [project.optional-dependencies]
+aiobreaker = ["aiobreaker>=0.3.0"]
 dev = [
   # Develope tools
   "pycln==2.5.0",
   "pre-commit==3.8.0",
-  "pyright==1.1.377",
+  "pyright==1.1.408",
   "ruff==0.6.2",
+  "vermin>=1.6.0",
+  "pytest-cov>=4.0.0",
+  "pytest-codspeed==4.2.0",
   # Tests
-  "aiokafka==0.10.0",
+  "aio-pika==9.3.0",  # from rabbit
+  "aiokafka==0.10.0",  # from kafka
+  "requests==2.*",  # from aiokafka
   "pytest~=7.4.2",
   "pytest-asyncio~=0.21.1",
   "pytest-env==0.6.2",
   "cryptography==42.0.2",
   "asyncmy==0.2.9",
-  "requests>=2.32.5"
+  "asyncpg>=0.29.0",
+  "redis>=5.0.0",
+  # Circuit breaker for tests
+  "aiobreaker>=0.3.0"  # from aiobreaker
 ]
 examples = [
   "fastapi==0.109.*",
-  "uvicorn==0.32.0",
   "faststream[kafka]==0.5.28",
-  "faker>=37.12.0"
-]
-kafka = [
-  "aiokafka==0.10.0",
-  # for SchemaRegistry
-  "confluent-kafka==2.6.0"
-]
-protobuf = ["protobuf==4.25.5"]
-rabbit = [
-  "aio-pika==9.3.0"
+  "faker>=37.12.0",
+  "uvicorn==0.32.0",
+  "aiohttp==3.13.2",
+  "protobuf>=4.25.8",
 ]
+kafka = ["aiokafka==0.10.0"]
+rabbit = ["aio-pika==9.3.0"]
+sqlalchemy = ["sqlalchemy[asyncio]==2.0.*"]
 
 [project.urls]
-Documentation = "https://vadikko2.github.io/python-cqrs-mkdocs/"
+Documentation = "https://mkdocs.python-cqrs.dev/"
 Issues = "https://github.com/vadikko2/python-cqrs/issues"
 Repository = "https://github.com/vadikko2/python-cqrs"
 
diff --git a/pyrightconfig.json b/pyrightconfig.json
index 5fae9df..2b2abd5 100644
--- a/pyrightconfig.json
+++ b/pyrightconfig.json
@@ -1,21 +1,27 @@
 {
   "venvPath": ".",
   "venv": "venv",
-  "include": ["src", "tests"],
+  "include": ["src", "tests", "benchmarks"],
   "exclude": ["**/__pycache__", "venv", "**/*_pb2.py"],
   "reportMissingImports": "error",
   "reportMissingTypeStubs": false,
   "defineConstant": {
     "DEBUG": true
   },
-  "pythonVersion": "3.12",
+  "pythonVersion": "3.10",
   "pythonPlatform": "Linux",
   "executionEnvironments": [
     {
       "root": "./",
-      "pythonVersion": "3.12",
+      "pythonVersion": "3.10",
       "pythonPlatform": "Linux",
       "reportMissingImports": "error"
+    },
+    {
+      "root": "./examples",
+      "pythonVersion": "3.10",
+      "pythonPlatform": "Linux",
+      "reportMissingImports": "warning"
     }
   ]
 }
diff --git a/ruff.toml b/ruff.toml
new file mode 100644
index 0000000..0fba781
--- /dev/null
+++ b/ruff.toml
@@ -0,0 +1,77 @@
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+
+# Same as Black.
+line-length = 120
+indent-width = 4
+
+# Assume Python 3.10
+target-version = "py310"
+
+[lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`) codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["E4", "E7", "E9", "F"]
+ignore = []
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[format]
+# Like Black, use double quotes for strings.
+quote-style = "double"
+
+# Like Black, indent with spaces, rather than tabs.
+indent-style = "space"
+
+# Like Black, respect magic trailing commas.
+skip-magic-trailing-comma = false
+
+# Like Black, automatically detect the appropriate line ending.
+line-ending = "auto"
+
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+docstring-code-format = false
+
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+docstring-code-line-length = "dynamic"
diff --git a/scripts/upload_proto.sh b/scripts/upload_proto.sh
deleted file mode 100644
index fed6f11..0000000
--- a/scripts/upload_proto.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-# This script is required to upload proto schema to Schema Registry
-# !/bin/bash
-user_joined_proto=$(cat ./examples/proto/user_joined.proto | jq -Rs .)
-echo "Upload schema: $user_joined_proto"
-
-curl -X POST http://localhost:8085/subjects/user_joined_proto-value/versions \
--H "Content-Type: application/vnd.schemaregistry.v1+json" \
--d '{
-  "schemaType": "PROTOBUF",
-  "schema": "syntax = \"proto3\";\n\nmessage UserJoinedECST {\n  message Payload {\n    string user_id = 1;\n    string meeting_id = 2;\n  }\n  string event_id = 1;\n  string event_timestamp = 2;\n  string event_name = 3;\n  Payload payload = 6;\n}\n\nmessage UserJoinedNotification {\n  message Payload {\n    string user_id = 1;\n    string meeting_id = 2;\n  }\n  string event_id = 1;\n  string event_timestamp = 2;\n  string event_name = 3;\n  Payload payload = 6;\n}\n"
-}'
diff --git a/src/cqrs/__init__.py b/src/cqrs/__init__.py
index 9060890..396f670 100644
--- a/src/cqrs/__init__.py
+++ b/src/cqrs/__init__.py
@@ -1,8 +1,23 @@
 from cqrs.compressors import Compressor, ZlibCompressor
 from cqrs.container.di import DIContainer
 from cqrs.container.protocol import Container
+from cqrs.circuit_breaker import ICircuitBreaker
 from cqrs.events import EventMap
-from cqrs.events.event import DomainEvent, Event, NotificationEvent
+from cqrs.events.fallback import EventHandlerFallback
+from cqrs.events.event import (
+    DCEvent,
+    DCDomainEvent,
+    DCNotificationEvent,
+    DomainEvent,
+    Event,
+    IDomainEvent,
+    IEvent,
+    INotificationEvent,
+    NotificationEvent,
+    PydanticDomainEvent,
+    PydanticEvent,
+    PydanticNotificationEvent,
+)
 from cqrs.events.event_emitter import EventEmitter
 from cqrs.events.event_handler import EventHandler
 from cqrs.mediator import (
@@ -12,43 +27,72 @@
     StreamingRequestMediator,
 )
 from cqrs.outbox.map import OutboxedEventMap
-from cqrs.outbox.repository import OutboxedEventRepository
+from cqrs.outbox.repository import (
+    EventStatus,
+    OutboxedEvent,
+    OutboxedEventRepository,
+)
 from cqrs.outbox.sqlalchemy import (
     rebind_outbox_model,
     SqlAlchemyOutboxedEventRepository,
 )
 from cqrs.producer import EventProducer
+from cqrs.requests.fallback import RequestHandlerFallback
 from cqrs.requests.map import RequestMap, SagaMap
-from cqrs.requests.request import Request
+from cqrs.requests.mermaid import CoRMermaid
+from cqrs.requests.request import DCRequest, IRequest, PydanticRequest, Request
 from cqrs.requests.request_handler import (
     RequestHandler,
     StreamingRequestHandler,
 )
-from cqrs.response import Response
-from cqrs.requests.mermaid import CoRMermaid
+from cqrs.response import DCResponse, IResponse, PydanticResponse, Response
 from cqrs.saga.mermaid import SagaMermaid
 from cqrs.saga.models import ContextT
 from cqrs.saga.saga import Saga
-from cqrs.saga.step import SagaStepHandler
+from cqrs.saga.step import (
+    Resp,
+    SagaStepHandler,
+    SagaStepResult,
+)
 
 __all__ = (
+    "ICircuitBreaker",
+    "EventHandlerFallback",
+    "RequestHandlerFallback",
     "RequestMediator",
     "SagaMediator",
     "StreamingRequestMediator",
     "EventMediator",
     "DomainEvent",
+    "IDomainEvent",
+    "DCDomainEvent",
+    "PydanticDomainEvent",
     "NotificationEvent",
+    "INotificationEvent",
+    "DCNotificationEvent",
+    "PydanticNotificationEvent",
     "Event",
+    "IEvent",
+    "DCEvent",
+    "PydanticEvent",
     "EventEmitter",
     "EventHandler",
     "EventMap",
     "OutboxedEventMap",
+    "EventStatus",
+    "OutboxedEvent",
     "Request",
+    "IRequest",
+    "DCRequest",
+    "PydanticRequest",
     "RequestHandler",
     "StreamingRequestHandler",
     "RequestMap",
     "SagaMap",
     "Response",
+    "IResponse",
+    "DCResponse",
+    "PydanticResponse",
     "OutboxedEventRepository",
     "SqlAlchemyOutboxedEventRepository",
     "EventProducer",
@@ -59,6 +103,8 @@
     "rebind_outbox_model",
     "Saga",
     "SagaStepHandler",
+    "SagaStepResult",
+    "Resp",
     "ContextT",
     "SagaMermaid",
     "CoRMermaid",
diff --git a/src/cqrs/adapters/amqp.py b/src/cqrs/adapters/amqp.py
index 512e692..7501af9 100644
--- a/src/cqrs/adapters/amqp.py
+++ b/src/cqrs/adapters/amqp.py
@@ -23,10 +23,19 @@ class AMQPPublisher(protocol.AMQPPublisher):
     def __init__(self, channel_pool: pool.Pool[aio_pika.abc.AbstractChannel]):
         self.channel_pool = channel_pool
 
-    async def publish(self, message: abc.AbstractMessage, queue_name: str, exchange_name: str) -> None:
+    async def publish(
+        self,
+        message: abc.AbstractMessage,
+        queue_name: str,
+        exchange_name: str,
+    ) -> None:
         async with self.channel_pool.acquire() as channel:
             queue = await channel.declare_queue(queue_name)
-            exchange = await channel.declare_exchange(exchange_name, type="direct", auto_delete=True)
+            exchange = await channel.declare_exchange(
+                exchange_name,
+                type="direct",
+                auto_delete=True,
+            )
             await queue.bind(exchange=exchange, routing_key=queue_name)
             await exchange.publish(message=message, routing_key=queue_name)
 
diff --git a/src/cqrs/adapters/circuit_breaker.py b/src/cqrs/adapters/circuit_breaker.py
new file mode 100644
index 0000000..46c5218
--- /dev/null
+++ b/src/cqrs/adapters/circuit_breaker.py
@@ -0,0 +1,247 @@
+"""Circuit breaker adapter for aiobreaker integration."""
+
+import logging
+import typing
+from datetime import timedelta
+from typing import TYPE_CHECKING, Callable
+
+from cqrs.circuit_breaker import ICircuitBreaker
+from cqrs.saga.circuit_breaker import ISagaStepCircuitBreaker
+
+logger = logging.getLogger("cqrs.adapters.circuit_breaker")
+
+if TYPE_CHECKING:
+    from aiobreaker.storage.base import CircuitBreakerStorage as _CircuitBreakerStorage
+else:
+    _CircuitBreakerStorage = typing.Any
+
+try:
+    import aiobreaker
+    from aiobreaker import CircuitBreaker, CircuitBreakerError
+    from aiobreaker.storage.base import CircuitBreakerStorage
+
+    try:
+        from aiobreaker import CircuitBreakerListener
+    except ImportError:
+        # Fallback if CircuitBreakerListener is not available
+        CircuitBreakerListener = object  # type: ignore[assignment, misc]
+except ImportError:
+    aiobreaker = None  # type: ignore[assignment, misc]
+    CircuitBreaker = None  # type: ignore[assignment, misc]
+    CircuitBreakerError = None  # type: ignore[assignment, misc]
+    CircuitBreakerListener = object  # type: ignore[assignment, misc]
+    CircuitBreakerStorage = typing.Any  # type: ignore[assignment, misc]
+
+    logger.warning(
+        "aiobreaker is not installed. Install it with: pip install aiobreaker",
+    )
+
+
+class CriticalLogListener(CircuitBreakerListener if aiobreaker else object):  # type: ignore[misc]
+    """
+    Listener for circuit breaker state changes with critical logging.
+
+    Implements CircuitBreakerListener interface methods.
+    """
+
+    def __init__(self, breaker_name: str):
+        self._breaker_name = breaker_name
+
+    def before_call(
+        self,
+        breaker: typing.Any,
+        func: typing.Any,
+        *args: typing.Any,
+        **kwargs: typing.Any,
+    ) -> None:
+        """Called before the circuit breaker calls the function."""
+        pass
+
+    def failure(self, breaker: typing.Any, exception: Exception) -> None:
+        """Called when the function fails."""
+        pass
+
+    def success(self, breaker: typing.Any) -> None:
+        """Called when the function succeeds."""
+        pass
+
+    def state_change(
+        self,
+        breaker: typing.Any,
+        old: typing.Any,
+        new: typing.Any,
+    ) -> None:
+        """Log circuit breaker state changes at critical level."""
+        logger.critical(
+            f"{self._breaker_name} circuit breaker state changed: {old.state} -> {new.state}",
+        )
+
+
+StorageFactory = Callable[[str], _CircuitBreakerStorage]
+
+
+def default_memory_storage_factory(name: str) -> _CircuitBreakerStorage:
+    """
+    Default factory returning Memory Storage.
+
+    Args:
+        name: Name of the circuit breaker (namespace).
+
+    Returns:
+        CircuitMemoryStorage instance.
+    """
+    if aiobreaker is None:
+        raise ImportError(
+            "aiobreaker is not installed. Install it with: pip install aiobreaker",
+        )
+
+    try:
+        from aiobreaker.storage.memory import CircuitMemoryStorage
+    except ImportError:
+        raise ImportError(
+            "Memory storage requires aiobreaker. Make sure aiobreaker is installed.",
+        )
+
+    return CircuitMemoryStorage(state=aiobreaker.CircuitBreakerState.CLOSED)
+
+
+def _identifier_to_name(identifier: type | str) -> str:
+    """Build circuit breaker namespace from type or string."""
+    if isinstance(identifier, str):
+        return identifier
+    module = getattr(identifier, "__module__", "")
+    name = getattr(identifier, "__name__", str(identifier))
+    return f"{module}.{name}" if module else name
+
+
+class AioBreakerAdapter(ICircuitBreaker, ISagaStepCircuitBreaker):
+    """
+    Unified adapter for aiobreaker circuit breaker.
+
+    Implements ICircuitBreaker (and ISagaStepCircuitBreaker for backward
+    compatibility). Each fallback type (Saga, Request, Event) typically
+    uses its own adapter instance; identifier can be a step/handler type
+    or a string for namespace.
+
+    Attributes:
+        fail_max: Maximum number of failures before opening the circuit.
+        timeout_duration: Time to wait before attempting to reset the circuit (in seconds).
+        exclude: List of exception types that should NOT open the circuit
+                (business exceptions).
+        storage_factory: Factory function to create circuit breaker storage.
+                        Defaults to in-memory storage.
+
+    Example::
+        # One adapter per fallback domain (each has its own breaker namespaces)
+        saga_cb = AioBreakerAdapter(fail_max=3, timeout_duration=60)
+        request_cb = AioBreakerAdapter(fail_max=5, timeout_duration=30)
+        event_cb = AioBreakerAdapter(fail_max=5, timeout_duration=30)
+    """
+
+    def __init__(
+        self,
+        fail_max: int = 5,
+        timeout_duration: int = 60,
+        exclude: list[type[Exception]] | None = None,
+        storage_factory: StorageFactory | None = None,
+    ) -> None:
+        if CircuitBreaker is None:
+            raise ImportError(
+                "aiobreaker is not installed. Install it with: pip install aiobreaker",
+            )
+
+        self._fail_max = fail_max
+        self._timeout_duration = timeout_duration
+        self._exclude = exclude or []
+        self._storage_factory = storage_factory or default_memory_storage_factory
+
+        # Dictionary to store circuit breakers per identifier (type or str)
+        self._breakers: dict[str, typing.Any] = {}  # type: ignore[type-arg]
+
+    def _get_breaker(self, identifier: type | str) -> typing.Any:  # type: ignore[return-type]
+        """
+        Get or create circuit breaker for an identifier (type or string).
+
+        Args:
+            identifier: Step/handler type or string for namespace.
+
+        Returns:
+            CircuitBreaker instance for this identifier.
+        """
+        name = _identifier_to_name(identifier)
+        if name not in self._breakers:
+            self._breakers[name] = self._create_breaker(name)
+        return self._breakers[name]
+
+    def _create_breaker(self, name: str) -> typing.Any:  # type: ignore[return-type]
+        """
+        Create circuit breaker for a step.
+
+        For each step, creates a breaker with storage from factory.
+        Each step gets its own isolated circuit breaker instance.
+
+        Args:
+            name: Name for the circuit breaker (step's fully qualified name).
+
+        Returns:
+            CircuitBreaker instance.
+        """
+        if CircuitBreaker is None:
+            raise ImportError(
+                "aiobreaker is not installed. Install it with: pip install aiobreaker",
+            )
+
+        # Create storage using factory
+        storage = self._storage_factory(name)
+
+        listeners: list[typing.Any] = [CriticalLogListener(name)]
+
+        return CircuitBreaker(
+            # When CircuitBreaker is not None, CircuitBreakerStorage is the actual type
+            state_storage=storage,  # type: ignore[arg-type]
+            name=name,
+            fail_max=self._fail_max,
+            timeout_duration=timedelta(seconds=self._timeout_duration),
+            exclude=self._exclude,
+            listeners=listeners,
+        )
+
+    async def call(
+        self,
+        identifier: type | str,
+        func: typing.Callable[..., typing.Awaitable[typing.Any]],
+        *args: typing.Any,
+        **kwargs: typing.Any,
+    ) -> typing.Any:
+        """
+        Execute the function with circuit breaker protection.
+
+        Args:
+            identifier: Step/handler type or string for breaker namespace.
+            func: The async function to execute.
+            *args: Positional arguments to pass to func.
+            **kwargs: Keyword arguments to pass to func.
+
+        Returns:
+            The result of func execution.
+
+        Raises:
+            CircuitBreakerError: If the circuit breaker is open.
+            Exception: Any exception raised by func (if circuit is closed).
+        """
+        breaker = self._get_breaker(identifier)
+        return await breaker.call_async(func, *args, **kwargs)
+
+    def is_circuit_breaker_error(self, exc: Exception) -> bool:
+        """
+        Check if the given exception is a circuit breaker error.
+
+        Args:
+            exc: The exception to check.
+
+        Returns:
+            True if the exception is a CircuitBreakerError, False otherwise.
+        """
+        if CircuitBreakerError is None:
+            return False
+        return isinstance(exc, CircuitBreakerError)
diff --git a/src/cqrs/adapters/protocol.py b/src/cqrs/adapters/protocol.py
index 86a1a1d..7886909 100644
--- a/src/cqrs/adapters/protocol.py
+++ b/src/cqrs/adapters/protocol.py
@@ -1,6 +1,7 @@
 import typing
 
-import aio_pika
+if typing.TYPE_CHECKING:
+    import aio_pika
 
 
 class KafkaProducer(typing.Protocol):
@@ -14,7 +15,7 @@ async def produce(
 class AMQPPublisher(typing.Protocol):
     async def publish(
         self,
-        message: aio_pika.abc.AbstractMessage,
+        message: "aio_pika.abc.AbstractMessage",
         queue_name: str,
         exchange_name: str,
     ) -> None: ...
@@ -23,6 +24,9 @@ async def publish(
 class AMQPConsumer(typing.Protocol):
     async def consume(
         self,
-        handler: typing.Callable[[aio_pika.abc.AbstractIncomingMessage], typing.Awaitable[None]],
+        handler: typing.Callable[
+            ["aio_pika.abc.AbstractIncomingMessage"],
+            typing.Awaitable[None],
+        ],
         queue_name: str,
     ) -> None: ...
diff --git a/src/cqrs/circuit_breaker.py b/src/cqrs/circuit_breaker.py
new file mode 100644
index 0000000..172eab6
--- /dev/null
+++ b/src/cqrs/circuit_breaker.py
@@ -0,0 +1,77 @@
+"""Unified circuit breaker protocol for Saga, Request and Event fallbacks."""
+
+import typing
+
+
+class ICircuitBreaker(typing.Protocol):
+    """
+    Unified interface for circuit breaker implementations.
+
+    Used by Saga step fallbacks, Request handler fallbacks and Event handler
+    fallbacks. The same adapter class works for all with identifier-based
+    namespacing.
+
+    Note:
+        Implementors should use a dedicated adapter instance per domain (events,
+        requests, saga) to keep circuit breaker state isolated.
+    """
+
+    async def call(
+        self,
+        identifier: type | str,
+        func: typing.Callable[..., typing.Awaitable[typing.Any]],
+        *args: typing.Any,
+        **kwargs: typing.Any,
+    ) -> typing.Any:
+        """
+        Execute the function with circuit breaker protection.
+
+        Args:
+            identifier: Handler/step type or string used as circuit breaker namespace.
+            func: The async function to execute.
+            *args: Positional arguments to pass to func.
+            **kwargs: Keyword arguments to pass to func.
+
+        Returns:
+            The result of func execution.
+
+        Raises:
+            CircuitBreakerError: If the circuit breaker is open.
+            Exception: Any exception raised by func (if circuit is closed).
+        """
+        ...
+
+    def is_circuit_breaker_error(self, exc: Exception) -> bool:
+        """
+        Check if the given exception is a circuit breaker error.
+
+        Args:
+            exc: The exception to check.
+
+        Returns:
+            True if the exception is a circuit breaker error, False otherwise.
+        """
+        ...
+
+
+def should_use_fallback(
+    primary_error: Exception,
+    circuit_breaker: ICircuitBreaker | None,
+    failure_exceptions: tuple[type[Exception], ...],
+) -> bool:
+    """
+    Determine whether to invoke the fallback after primary handler failure.
+
+    Returns True if the circuit breaker reports a breaker error, or the
+    exception matches failure_exceptions, or failure_exceptions is empty
+    (any exception triggers fallback).
+    """
+    if circuit_breaker is not None and circuit_breaker.is_circuit_breaker_error(
+        primary_error,
+    ):
+        return True
+    if failure_exceptions and isinstance(primary_error, failure_exceptions):
+        return True
+    if not failure_exceptions:
+        return True
+    return False
diff --git a/src/cqrs/container/dependency_injector.py b/src/cqrs/container/dependency_injector.py
index e7fd7ab..a49b42d 100644
--- a/src/cqrs/container/dependency_injector.py
+++ b/src/cqrs/container/dependency_injector.py
@@ -1,4 +1,4 @@
-from typing import TypeVar, Type, Optional, cast
+from typing import TypeVar, Optional, cast
 import inspect
 import functools
 from dependency_injector import providers
@@ -9,7 +9,7 @@
 
 
 class DependencyInjectorCQRSContainer(
-    CQRSContainerProtocol[DependencyInjectorContainer]
+    CQRSContainerProtocol[DependencyInjectorContainer],
 ):
     """
     Adapter bridging dependency-injector containers with CQRS framework.
@@ -136,7 +136,7 @@ def attach_external_container(self, container: DependencyInjectorContainer) -> N
         self._get_provider.cache_clear()
         self._traverse_container(container)
 
-    async def resolve(self, type_: Type[T]) -> T:
+    async def resolve(self, type_: type[T]) -> T:
         """
         Resolve and instantiate a dependency by its type.
 
@@ -189,7 +189,13 @@ async def resolve(self, type_: Type[T]) -> T:
             ...         return await service.create_user(request.name)
         """
         provider = self._get_provider(type_)
-        return provider()
+        result = provider()
+        # If provider returns a coroutine or Future (async provider), await it
+        # Note: inspect.iscoroutine() only checks for coroutines, not Futures/Tasks
+        # We need to check for any awaitable object
+        if inspect.isawaitable(result):
+            return await result
+        return result
 
     def _traverse_container(
         self,
@@ -268,7 +274,7 @@ def _traverse_container(
     def _get_provider_by_path_segments(
         self,
         path_segments: tuple[str, ...],
-    ) -> providers.Provider[T]:
+    ) -> providers.Provider[object]:
         """
         Navigate container hierarchy to retrieve a provider by its access path.
 
@@ -309,7 +315,7 @@ def _get_provider_by_path_segments(
     @functools.cache
     def _get_provider(
         self,
-        requested_type: Type[T],
+        requested_type: type[T],
     ) -> providers.Provider[T]:
         """
         Find and return the provider for a requested type with caching.
@@ -370,8 +376,11 @@ def _get_provider(
         """
         # Strategy 1: Exact type match
         if requested_type in self._type_to_provider_path_map:
-            return self._get_provider_by_path_segments(
-                self._type_to_provider_path_map[requested_type]
+            return cast(
+                providers.Provider[T],
+                self._get_provider_by_path_segments(
+                    self._type_to_provider_path_map[requested_type],
+                ),
             )
 
         # Strategy 2: Inheritance-based match
@@ -379,12 +388,15 @@ def _get_provider(
         # This enables resolving abstract base classes to their concrete implementations
         for registered_type in self._type_to_provider_path_map:
             if issubclass(registered_type, requested_type):
-                return self._get_provider_by_path_segments(
-                    self._type_to_provider_path_map[registered_type]
+                return cast(
+                    providers.Provider[T],
+                    self._get_provider_by_path_segments(
+                        self._type_to_provider_path_map[registered_type],
+                    ),
                 )
 
         # No provider found for the requested type
         raise ValueError(
             f"Provider for type {requested_type.__name__} not found. "
-            f"Ensure the type is registered in the dependency-injector container."
+            f"Ensure the type is registered in the dependency-injector container.",
         )
diff --git a/src/cqrs/deserializers/__init__.py b/src/cqrs/deserializers/__init__.py
index f7ea6eb..115a56b 100644
--- a/src/cqrs/deserializers/__init__.py
+++ b/src/cqrs/deserializers/__init__.py
@@ -1,13 +1,8 @@
-from cqrs.deserializers.exceptions import (
-    DeserializeJsonError,
-    DeserializeProtobufError,
-)
-from cqrs.deserializers.json import JsonDeserializer
-from cqrs.deserializers.protobuf import ProtobufValueDeserializer
+from cqrs.deserializers.exceptions import DeserializeJsonError
+from cqrs.deserializers.json import Deserializable, JsonDeserializer
 
 __all__ = (
+    "Deserializable",
     "JsonDeserializer",
     "DeserializeJsonError",
-    "ProtobufValueDeserializer",
-    "DeserializeProtobufError",
 )
diff --git a/src/cqrs/deserializers/exceptions.py b/src/cqrs/deserializers/exceptions.py
index 3152059..4cb2d0a 100644
--- a/src/cqrs/deserializers/exceptions.py
+++ b/src/cqrs/deserializers/exceptions.py
@@ -1,15 +1,18 @@
+import dataclasses
 import typing
 
-import pydantic
 
+@dataclasses.dataclass(frozen=True)
+class DeserializeJsonError:
+    """
+    Error that occurred during JSON deserialization.
 
-class DeserializeJsonError(pydantic.BaseModel):
-    error_message: str
-    error_type: typing.Type[Exception]
-    message_data: str | bytes | None
+    Args:
+        error_message: Human-readable error message
+        error_type: Type of the exception that occurred
+        message_data: The original message data that failed to deserialize
+    """
 
-
-class DeserializeProtobufError(pydantic.BaseModel):
     error_message: str
     error_type: typing.Type[Exception]
-    message_data: bytes
+    message_data: str | bytes | None
diff --git a/src/cqrs/deserializers/json.py b/src/cqrs/deserializers/json.py
index 27fe056..9f25565 100644
--- a/src/cqrs/deserializers/json.py
+++ b/src/cqrs/deserializers/json.py
@@ -1,25 +1,103 @@
 import logging
 import typing
+import sys
 
-import pydantic
+import orjson
 
 from cqrs.deserializers.exceptions import DeserializeJsonError
 
-_T = typing.TypeVar("_T", bound=pydantic.BaseModel)
+if sys.version_info >= (3, 11):
+    from typing import Self  # novm
+else:
+    from typing_extensions import Self
 
 logger = logging.getLogger("cqrs")
 
 
+class Deserializable(typing.Protocol):
+    """
+    Protocol for objects that can be deserialized from a dictionary.
+
+    Objects implementing this protocol must have a classmethod `from_dict`
+    that creates an instance from keyword arguments.
+    """
+
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        """
+        Create an instance from keyword arguments.
+
+        Args:
+            **kwargs: Keyword arguments matching the object fields.
+
+        Returns:
+            A new instance of the class.
+        """
+        ...
+
+
+_T = typing.TypeVar("_T", bound=Deserializable)
+
+
 class JsonDeserializer(typing.Generic[_T]):
-    def __init__(self, model: typing.Type[_T]):
-        self._model: typing.Type[_T] = model
+    """
+    Deserializer for JSON messages.
+
+    Converts JSON strings or bytes into Python objects using the `from_dict`
+    classmethod of the target model.
+
+    Example::
+
+        deserializer = JsonDeserializer(MyEvent)
+        result = deserializer('{"field": "value"}')
+        if isinstance(result, DeserializeJsonError):
+            # Handle error
+        else:
+            # Use result
+    """
+
+    def __init__(self, model: typing.Type[typing.Any]):
+        """
+        Initialize JSON deserializer.
+
+        Args:
+            model: Class that implements Deserializable protocol (has a from_dict classmethod).
+                   Can be a regular type or a parameterized generic type
+                   (e.g., NotificationEvent[PayloadType]).
+
+        Note:
+            The model type must implement the Deserializable protocol (have a from_dict
+            classmethod). This is verified at runtime. For proper type inference,
+            specify the generic parameter: JsonDeserializer[ConcreteType](model=...)
+        """
+        # Runtime check: verify that model implements Deserializable protocol
+        if not hasattr(model, "from_dict") or not callable(
+            getattr(model, "from_dict", None),
+        ):
+            raise TypeError(
+                f"Model {model} does not implement Deserializable protocol: " "missing 'from_dict' classmethod",
+            )
+        # Store model - type is preserved through generic parameter _T for return type
+        self._model: typing.Type[typing.Any] = model
 
     def __call__(self, data: str | bytes | None) -> _T | None | DeserializeJsonError:
-        if data is None:
-            return
+        """
+        Deserialize JSON data into model instance.
 
+        Args:
+            data: JSON string, bytes, or None
+
+        Returns:
+            Instance of the model, None if data is None, or DeserializeJsonError on failure.
+        """
+        if data is None:
+            return None
         try:
-            return self._model.model_validate_json(data)
+            json_dict = orjson.loads(data)
+            # Safe cast: model is Type[_T] where _T bound=Deserializable,
+            # so from_dict is guaranteed to return _T
+            result = self._model.from_dict(**json_dict)
+            return typing.cast(_T, result)
         except Exception as e:
             logger.error(
                 f"Error while deserializing json message: {e}",
diff --git a/src/cqrs/deserializers/protobuf.py b/src/cqrs/deserializers/protobuf.py
deleted file mode 100644
index 31f5532..0000000
--- a/src/cqrs/deserializers/protobuf.py
+++ /dev/null
@@ -1,66 +0,0 @@
-import logging
-import typing
-
-import cqrs
-import pydantic
-from confluent_kafka.schema_registry import protobuf
-from google.protobuf.message import Message
-
-from cqrs.deserializers.exceptions import DeserializeProtobufError
-
-logger = logging.getLogger("cqrs")
-
-
-class ProtobufValueDeserializer:
-    """
-    Deserialize protobuf message into CQRS event model.
-    """
-
-    def __init__(
-        self,
-        model: typing.Type[cqrs.NotificationEvent],
-        protobuf_model: typing.Type[Message],
-    ):
-        self._model = model
-        self._protobuf_model = protobuf_model
-
-    def __call__(
-        self,
-        msg: typing.ByteString,
-    ) -> cqrs.NotificationEvent | DeserializeProtobufError:
-        protobuf_deserializer = protobuf.ProtobufDeserializer(
-            self._protobuf_model,
-            {"use.deprecated.format": False},
-        )
-        try:
-            proto_event = protobuf_deserializer(msg, None)
-        except Exception as error:
-            logger.error(
-                f"Error while deserializing protobuf message: {error}",
-            )
-            return DeserializeProtobufError(
-                error_message=str(error),
-                error_type=type(error),
-                message_data=bytes(msg),
-            )
-
-        if proto_event is None:
-            logger.debug("Protobuf message is empty")
-            empty_error = ValueError("Protobuf message is empty")
-            return DeserializeProtobufError(
-                error_message=str(empty_error),
-                error_type=type(empty_error),
-                message_data=bytes(msg),
-            )
-
-        try:
-            return self._model.model_validate(proto_event)
-        except pydantic.ValidationError as error:
-            logger.error(
-                f"Error while validate proto event into model {self._model.__name__}: {error}",
-            )
-            return DeserializeProtobufError(
-                error_message=str(error),
-                error_type=type(error),
-                message_data=bytes(msg),
-            )
diff --git a/src/cqrs/dispatcher/event.py b/src/cqrs/dispatcher/event.py
index 5408372..a6b0169 100644
--- a/src/cqrs/dispatcher/event.py
+++ b/src/cqrs/dispatcher/event.py
@@ -2,8 +2,9 @@
 import typing
 
 from cqrs.container.protocol import Container
-from cqrs.events.event import Event
+from cqrs.events.event import IEvent
 from cqrs.events.event_handler import EventHandler
+from cqrs.events.fallback import EventHandlerFallback
 from cqrs.events.map import EventMap
 from cqrs.middlewares.base import MiddlewareChain
 
@@ -25,18 +26,71 @@ def __init__(
 
     async def _handle_event(
         self,
-        event: Event,
+        event: IEvent,
         handle_type: typing.Type[_EventHandler],
-    ):
+    ) -> None:
         handler: _EventHandler = await self._container.resolve(handle_type)
         await handler.handle(event)
+        for follow_up in handler.events:
+            await self.dispatch(follow_up)
+
+    async def _handle_event_fallback(
+        self,
+        event: IEvent,
+        fallback_config: EventHandlerFallback,
+    ) -> None:
+        """Run primary handler with fallback on failure; dispatch follow-up events from the handler that ran."""
+        primary: _EventHandler = await self._container.resolve(fallback_config.primary)
+        try:
+            if fallback_config.circuit_breaker is not None:
+                await fallback_config.circuit_breaker.call(
+                    fallback_config.primary,
+                    primary.handle,
+                    event,
+                )
+            else:
+                await primary.handle(event)
+            for follow_up in primary.events:
+                await self.dispatch(follow_up)
+        except Exception as primary_error:
+            should_fallback = False
+            if fallback_config.circuit_breaker is not None and fallback_config.circuit_breaker.is_circuit_breaker_error(
+                primary_error,
+            ):
+                should_fallback = True
+            elif fallback_config.failure_exceptions and isinstance(
+                primary_error,
+                fallback_config.failure_exceptions,
+            ):
+                should_fallback = True
+            elif not fallback_config.failure_exceptions:
+                should_fallback = True
+            if should_fallback:
+                logger.warning(
+                    "Primary event handler %s failed: %s. Switching to fallback %s.",
+                    fallback_config.primary.__name__,
+                    primary_error,
+                    fallback_config.fallback.__name__,
+                )
+                fallback_handler: _EventHandler = await self._container.resolve(
+                    fallback_config.fallback,
+                )
+                await fallback_handler.handle(event)
+                for follow_up in fallback_handler.events:
+                    await self.dispatch(follow_up)
+            else:
+                raise primary_error
 
-    async def dispatch(self, event: Event) -> None:
+    async def dispatch(self, event: IEvent) -> None:
         handler_types = self._event_map.get(type(event), [])
         if not handler_types:
             logger.warning(
                 "Handlers for event %s not found",
                 type(event).__name__,
             )
+            return
         for h_type in handler_types:
-            await self._handle_event(event, h_type)
+            if isinstance(h_type, EventHandlerFallback):
+                await self._handle_event_fallback(event, h_type)
+            else:
+                await self._handle_event(event, h_type)
diff --git a/src/cqrs/dispatcher/models.py b/src/cqrs/dispatcher/models.py
index 4c82cb9..5db8e44 100644
--- a/src/cqrs/dispatcher/models.py
+++ b/src/cqrs/dispatcher/models.py
@@ -2,13 +2,13 @@
 import logging
 import typing
 
-from cqrs.events.event import Event
-from cqrs.response import Response
+from cqrs.events.event import IEvent
+from cqrs.response import IResponse
 from cqrs.saga.step import SagaStepResult
 
 logger = logging.getLogger("cqrs")
 
-_ResponseT = typing.TypeVar("_ResponseT", Response, None, covariant=True)
+_ResponseT = typing.TypeVar("_ResponseT", IResponse, None, covariant=True)
 
 
 @dataclasses.dataclass
@@ -16,7 +16,7 @@ class RequestDispatchResult(typing.Generic[_ResponseT]):
     """Result of request dispatch execution."""
 
     response: _ResponseT
-    events: typing.List[Event] = dataclasses.field(default_factory=list)
+    events: typing.Sequence[IEvent] = dataclasses.field(default_factory=list)
 
 
 @dataclasses.dataclass
@@ -24,5 +24,5 @@ class SagaDispatchResult:
     """Result of saga dispatch execution for a single step."""
 
     step_result: SagaStepResult
-    events: typing.List[Event] = dataclasses.field(default_factory=list)
+    events: typing.List[IEvent] = dataclasses.field(default_factory=list)
     saga_id: str | None = None
diff --git a/src/cqrs/dispatcher/request.py b/src/cqrs/dispatcher/request.py
index eb4e9ed..8e9b5cd 100644
--- a/src/cqrs/dispatcher/request.py
+++ b/src/cqrs/dispatcher/request.py
@@ -3,6 +3,7 @@
 import typing
 from collections import abc
 
+from cqrs.circuit_breaker import should_use_fallback
 from cqrs.container.protocol import Container
 from cqrs.dispatcher.exceptions import (
     RequestHandlerDoesNotExist,
@@ -15,8 +16,9 @@
     build_chain,
     CORRequestHandlerT as CORRequestHandlerType,
 )
+from cqrs.requests.fallback import RequestHandlerFallback
 from cqrs.requests.map import RequestMap, HandlerType
-from cqrs.requests.request import Request
+from cqrs.requests.request import IRequest
 from cqrs.requests.request_handler import RequestHandler
 
 logger = logging.getLogger("cqrs")
@@ -44,7 +46,12 @@ async def _resolve_handler(
 
         For single handlers, resolves them using the DI container.
         For lists of handlers, validates they are COR handlers and builds a chain.
+        RequestHandlerFallback is not resolved here; use dispatch fallback path.
         """
+        if isinstance(handler_type, RequestHandlerFallback):
+            raise RequestHandlerTypeError(
+                "RequestHandlerFallback must be handled in dispatch, not _resolve_handler",
+            )
         if isinstance(handler_type, abc.Iterable):
             if not all(
                 issubclass(
@@ -57,23 +64,74 @@ async def _resolve_handler(
                     "COR handler must be type CORRequestHandler",
                 )
 
-            async with asyncio.TaskGroup() as tg:
-                tasks = [
-                    tg.create_task(self._container.resolve(h)) for h in handler_type
-                ]
-            handlers = [task.result() for task in tasks]
+            tasks = [self._container.resolve(h) for h in handler_type]
+            handlers = await asyncio.gather(*tasks)
             return build_chain(
                 typing.cast(typing.List[CORRequestHandlerType], handlers),
             )
 
         return typing.cast(_RequestHandler, await self._container.resolve(handler_type))
 
-    async def dispatch(self, request: Request) -> RequestDispatchResult:
+    async def _dispatch_fallback(
+        self,
+        request: IRequest,
+        fallback_config: RequestHandlerFallback,
+    ) -> RequestDispatchResult:
+        """Dispatch using primary handler with fallback on failure."""
+        primary = await self._container.resolve(fallback_config.primary)
+        try:
+            wrapped_primary = self._middleware_chain.wrap(primary.handle)
+            if fallback_config.circuit_breaker is not None:
+                response = await fallback_config.circuit_breaker.call(
+                    fallback_config.primary,
+                    wrapped_primary,
+                    request,
+                )
+            else:
+                response = await wrapped_primary(request)
+            return RequestDispatchResult(response=response, events=primary.events)
+        except Exception as primary_error:
+            should_fallback = should_use_fallback(
+                primary_error,
+                fallback_config.circuit_breaker,
+                fallback_config.failure_exceptions,
+            )
+            if should_fallback:
+                if (
+                    fallback_config.circuit_breaker is not None
+                    and fallback_config.circuit_breaker.is_circuit_breaker_error(
+                        primary_error,
+                    )
+                ):
+                    logger.warning(
+                        "Circuit breaker open for request handler %s, switching to fallback %s",
+                        fallback_config.primary.__name__,
+                        fallback_config.fallback.__name__,
+                    )
+                else:
+                    logger.warning(
+                        "Primary handler %s failed: %s. Switching to fallback %s.",
+                        fallback_config.primary.__name__,
+                        primary_error,
+                        fallback_config.fallback.__name__,
+                    )
+                fallback_handler = await self._container.resolve(fallback_config.fallback)
+                wrapped_fallback = self._middleware_chain.wrap(fallback_handler.handle)
+                response = await wrapped_fallback(request)
+                return RequestDispatchResult(
+                    response=response,
+                    events=fallback_handler.events,
+                )
+            raise primary_error
+
+    async def dispatch(self, request: IRequest) -> RequestDispatchResult:
         handler_type = self._request_map.get(type(request), None)
         if not handler_type:
             raise RequestHandlerDoesNotExist(
                 f"RequestHandler not found matching Request type {type(request)}",
             )
+        if isinstance(handler_type, RequestHandlerFallback):
+            return await self._dispatch_fallback(request, handler_type)
         handler: _RequestHandler = await self._resolve_handler(handler_type)
         wrapped_handle = self._middleware_chain.wrap(handler.handle)
         response = await wrapped_handle(request)
diff --git a/src/cqrs/dispatcher/saga.py b/src/cqrs/dispatcher/saga.py
index d3b2328..d3e3202 100644
--- a/src/cqrs/dispatcher/saga.py
+++ b/src/cqrs/dispatcher/saga.py
@@ -53,7 +53,7 @@ def __init__(
         self._compensation_retry_delay = compensation_retry_delay
         self._compensation_retry_backoff = compensation_retry_backoff
 
-    async def dispatch(
+    def dispatch(
         self,
         context: SagaContext,
         saga_id: uuid.UUID | None = None,
@@ -61,6 +61,7 @@ async def dispatch(
         """
         Dispatch a saga execution for the given context.
 
+        Called without await; returns an AsyncIterator consumed with async for.
         Yields result after each step execution. After each yield, events are collected
         and included in the dispatch result.
 
@@ -75,6 +76,13 @@ async def dispatch(
         Raises:
             SagaDoesNotExist: If no saga is registered for the context type
         """
+        return self._dispatch_impl(context, saga_id=saga_id)
+
+    async def _dispatch_impl(
+        self,
+        context: SagaContext,
+        saga_id: uuid.UUID | None = None,
+    ) -> typing.AsyncIterator[SagaDispatchResult]:
         # Find saga type by context type
         saga_type = self._saga_map.get(type(context))
         if not saga_type:
diff --git a/src/cqrs/dispatcher/streaming.py b/src/cqrs/dispatcher/streaming.py
index a985e01..2caabec 100644
--- a/src/cqrs/dispatcher/streaming.py
+++ b/src/cqrs/dispatcher/streaming.py
@@ -1,14 +1,19 @@
 import inspect
+import logging
 import typing
 
+from cqrs.circuit_breaker import should_use_fallback
 from cqrs.container.protocol import Container
 from cqrs.dispatcher.exceptions import RequestHandlerDoesNotExist
 from cqrs.dispatcher.models import RequestDispatchResult
 from cqrs.middlewares.base import MiddlewareChain
+from cqrs.requests.fallback import RequestHandlerFallback
 from cqrs.requests.map import RequestMap
-from cqrs.requests.request import Request
+from cqrs.requests.request import IRequest
 from cqrs.requests.request_handler import StreamingRequestHandler
 
+logger = logging.getLogger("cqrs")
+
 
 class StreamingRequestDispatcher:
     """
@@ -16,6 +21,13 @@ class StreamingRequestDispatcher:
 
     This dispatcher handles requests using handlers that yield responses
     as generators. After each yield, events are collected and can be emitted.
+
+    When a primary streaming handler (used via RequestHandlerFallback) fails
+    mid-stream, already-yielded RequestDispatchResult items are not rolled
+    back and the fallback handler streams from its start. Results may
+    therefore be duplicated; callers can de-duplicate if needed. The
+    fallback path is driven by _stream_from_handler and handler_type
+    (primary vs fallback).
     """
 
     def __init__(
@@ -28,54 +40,107 @@ def __init__(
         self._container = container
         self._middleware_chain = middleware_chain or MiddlewareChain()
 
-    async def dispatch(
+    def dispatch(
         self,
-        request: Request,
+        request: IRequest,
     ) -> typing.AsyncIterator[RequestDispatchResult]:
         """
         Dispatch a request to a streaming handler and yield results.
 
+        Called without await; returns an AsyncIterator consumed with async for.
         After each yield from the handler, events are collected and included
         in the dispatch result. The generator continues until StopIteration.
         """
+        return self._dispatch_impl(request)
+
+    @staticmethod
+    async def _stream_from_handler(
+        request: IRequest,
+        handler: StreamingRequestHandler,
+    ) -> typing.AsyncIterator[RequestDispatchResult]:
+        async for response in handler.handle(request):
+            events = list(handler.events)
+            handler.clear_events()
+            yield RequestDispatchResult(response=response, events=events)
+
+    async def _dispatch_impl(
+        self,
+        request: IRequest,
+    ) -> typing.AsyncIterator[RequestDispatchResult]:
+        """
+        Dispatch to the mapped handler. For RequestHandlerFallback, on primary
+        failure the fallback streams from scratch (see class docstring).
+        """
         handler_type = self._request_map.get(type(request), None)
         if handler_type is None:
-            raise RequestHandlerDoesNotExist(
-                f"StreamingRequestHandler not found matching Request type {type(request)}",
-            )
+            raise RequestHandlerDoesNotExist(f"StreamingRequestHandler not found matching Request type {type(request)}")
 
-        # Streaming dispatcher only works with streaming handlers, not lists
         if isinstance(handler_type, list):
             raise TypeError(
                 "StreamingRequestDispatcher does not support COR handler chains. "
                 "Use RequestDispatcher for chain of responsibility pattern.",
             )
 
-        # Type narrowing: handler_type is now a single handler type
-        handler_type_typed = typing.cast(
-            typing.Type[StreamingRequestHandler],
-            handler_type,
-        )
-        handler: StreamingRequestHandler = await self._container.resolve(
-            handler_type_typed,
-        )
+        if isinstance(handler_type, RequestHandlerFallback):
+            primary = await self._container.resolve(handler_type.primary)
+            fallback_handler = await self._container.resolve(handler_type.fallback)
+            if not inspect.isasyncgenfunction(primary.handle) or not inspect.isasyncgenfunction(
+                fallback_handler.handle,
+            ):
+                raise TypeError(
+                    "RequestHandlerFallback with StreamingRequestDispatcher requires "
+                    "both primary and fallback to be async generator handlers",
+                )
+            try:
+                async for result in self._stream_from_handler(
+                    request,
+                    typing.cast(StreamingRequestHandler, primary),
+                ):
+                    yield result
+            except Exception as primary_error:
+                should_fallback = should_use_fallback(
+                    primary_error,
+                    handler_type.circuit_breaker,
+                    handler_type.failure_exceptions,
+                )
+                if should_fallback:
+                    if (
+                        handler_type.circuit_breaker is not None
+                        and handler_type.circuit_breaker.is_circuit_breaker_error(
+                            primary_error,
+                        )
+                    ):
+                        logger.warning(
+                            "Circuit breaker open for streaming handler %s, switching to fallback %s",
+                            handler_type.primary.__name__,
+                            handler_type.fallback.__name__,
+                        )
+                    else:
+                        logger.warning(
+                            "Primary streaming handler %s failed: %s. Switching to fallback %s.",
+                            handler_type.primary.__name__,
+                            primary_error,
+                            handler_type.fallback.__name__,
+                        )
+                    async for result in self._stream_from_handler(
+                        request,
+                        typing.cast(StreamingRequestHandler, fallback_handler),
+                    ):
+                        yield result
+                else:
+                    raise primary_error
+            return
+
+        handler_type_typed = typing.cast(typing.Type[StreamingRequestHandler], handler_type)
+        handler: StreamingRequestHandler = await self._container.resolve(handler_type_typed)
 
         if not inspect.isasyncgenfunction(handler.handle):
             handler_name = (
-                handler_type_typed.__name__
-                if hasattr(handler_type_typed, "__name__")
-                else str(handler_type_typed)
+                handler_type_typed.__name__ if hasattr(handler_type_typed, "__name__") else str(handler_type_typed)
             )
             raise TypeError(
                 f"Handler {handler_name}.handle must be an async generator function",
             )
 
-        async_gen = handler.handle(request)
-        async for response in async_gen:
-            events = handler.events.copy()
-            if hasattr(handler, "clear_events"):
-                handler.clear_events()
-            yield RequestDispatchResult(
-                response=response,
-                events=events,
-            )
+        async for result in self._stream_from_handler(request, handler):
+            yield result
diff --git a/src/cqrs/events/__init__.py b/src/cqrs/events/__init__.py
index 3587773..b08c93d 100644
--- a/src/cqrs/events/__init__.py
+++ b/src/cqrs/events/__init__.py
@@ -1,13 +1,50 @@
-from cqrs.events.event import DomainEvent, Event, NotificationEvent
+"""Event types, handlers, emitter, and event map for the CQRS events layer.
+
+Public API:
+- Event types: :class:`Event`, :class:`DomainEvent`, :class:`NotificationEvent`,
+  and their interfaces/base classes.
+- :class:`EventHandler` — handler interface; implement :meth:`EventHandler.handle`
+  and optionally :attr:`EventHandler.events` for follow-up events.
+- :class:`EventEmitter` — sends domain events to handlers and notification events
+  to a message broker.
+- :class:`EventMap` — registry of event type -> handler types; use :meth:`EventMap.bind`.
+- :class:`EventHandlerFallback` — fallback wrapper for event handlers with optional circuit breaker.
+"""
+
+from cqrs.events.event import (
+    DCEvent,
+    DCDomainEvent,
+    DCNotificationEvent,
+    DomainEvent,
+    Event,
+    IDomainEvent,
+    IEvent,
+    INotificationEvent,
+    NotificationEvent,
+    PydanticDomainEvent,
+    PydanticEvent,
+    PydanticNotificationEvent,
+)
 from cqrs.events.event_emitter import EventEmitter
 from cqrs.events.event_handler import EventHandler
+from cqrs.events.fallback import EventHandlerFallback
 from cqrs.events.map import EventMap
 
 __all__ = (
     "Event",
+    "IEvent",
+    "DCEvent",
+    "PydanticEvent",
     "DomainEvent",
+    "IDomainEvent",
+    "DCDomainEvent",
+    "PydanticDomainEvent",
     "NotificationEvent",
+    "INotificationEvent",
+    "DCNotificationEvent",
+    "PydanticNotificationEvent",
     "EventEmitter",
     "EventHandler",
+    "EventHandlerFallback",
     "EventMap",
 )
diff --git a/src/cqrs/events/bootstrap.py b/src/cqrs/events/bootstrap.py
index f6f771b..36da6b1 100644
--- a/src/cqrs/events/bootstrap.py
+++ b/src/cqrs/events/bootstrap.py
@@ -31,6 +31,31 @@ def setup_mediator(
     middlewares: typing.Iterable[mediator_middlewares.Middleware],
     events_mapper: typing.Callable[[events.EventMap], None] | None = None,
 ) -> cqrs.EventMediator:
+    """
+    Create an event mediator with the given container and middlewares.
+
+    Args:
+        container: DI container (e.g. :class:`cqrs.container.di.DIContainer`) or
+            any implementation of :class:`cqrs.container.protocol.Container`.
+        middlewares: Middleware chain for the mediator (e.g. logging).
+        events_mapper: Optional callable that receives an :class:`~cqrs.events.map.EventMap`
+            and binds event types to handler types via :meth:`~cqrs.events.map.EventMap.bind`.
+
+    Returns:
+        Configured :class:`cqrs.EventMediator` instance.
+
+    Example::
+
+        def bind_events(event_map: events.EventMap) -> None:
+            event_map.bind(OrderCreatedEvent, OrderCreatedEventHandler)
+
+        mediator = setup_mediator(
+            container=di_container,
+            middlewares=[logging_middleware.LoggingMiddleware()],
+            events_mapper=bind_events,
+        )
+        await mediator.emit(OrderCreatedEvent(order_id="1"))
+    """
     _events_mapper = events.EventMap()
     if events_mapper is not None:
         events_mapper(_events_mapper)
@@ -71,6 +96,34 @@ def bootstrap(
     events_mapper: typing.Callable[[events.EventMap], None] | None = None,
     on_startup: typing.List[typing.Callable[[], None]] | None = None,
 ) -> cqrs.EventMediator:
+    """
+    Bootstrap an event mediator with optional middlewares and event bindings.
+
+    If ``di_container`` is a :class:`di.Container`, it is wrapped in
+    :class:`cqrs.container.di.DIContainer`. Logging middleware is appended
+    to the middleware list. Runs all ``on_startup`` callables before setup.
+
+    Args:
+        di_container: DI container from the ``di`` package or a CQRS container.
+        middlewares: Optional list of middlewares (e.g. logging, metrics).
+        events_mapper: Optional callable that receives an :class:`~cqrs.events.map.EventMap`
+            and binds event types to handler types.
+        on_startup: Optional list of callables to run before creating the mediator.
+
+    Returns:
+        Configured :class:`cqrs.EventMediator` with logging middleware enabled.
+
+    Example::
+
+        def bind_events(event_map: events.EventMap) -> None:
+            event_map.bind(OrderCreatedEvent, OrderCreatedEventHandler)
+
+        mediator = bootstrap(
+            di_container=di.Container(),
+            events_mapper=bind_events,
+        )
+        await mediator.emit(OrderCreatedEvent(order_id="1"))
+    """
     if on_startup is None:
         on_startup = []
 
@@ -90,8 +143,10 @@ def bootstrap(
     middlewares_list: typing.List[mediator_middlewares.Middleware] = list(
         middlewares or [],
     )
+    if not any(isinstance(m, logging_middleware.LoggingMiddleware) for m in middlewares_list):
+        middlewares_list.append(logging_middleware.LoggingMiddleware())
     return setup_mediator(
         container,
         events_mapper=events_mapper,
-        middlewares=middlewares_list + [logging_middleware.LoggingMiddleware()],
+        middlewares=middlewares_list,
     )
diff --git a/src/cqrs/events/event.py b/src/cqrs/events/event.py
index 3364f0f..b2b9771 100644
--- a/src/cqrs/events/event.py
+++ b/src/cqrs/events/event.py
@@ -1,10 +1,19 @@
+import abc
+import dataclasses
 import datetime
 import os
+import sys
 import typing
 import uuid
 
 import dotenv
 import pydantic
+from dataclass_wizard import asdict, fromdict
+
+if sys.version_info >= (3, 11):
+    from typing import Self  # novm
+else:
+    from typing_extensions import Self
 
 dotenv.load_dotenv()
 DEFAULT_OUTPUT_TOPIC = os.getenv("DEFAULT_OUTPUT_TOPIC", "output_topic")
@@ -13,23 +22,334 @@
 PayloadT = typing.TypeVar("PayloadT", bound=typing.Any)
 
 
-class Event(pydantic.BaseModel, frozen=True):
+class IEvent(abc.ABC):
     """
-    The base class for events
+    Interface for event-type objects.
+
+    This abstract base class defines the contract that all event implementations
+    must follow. Events represent domain events or notification events in the
+    CQRS pattern and are used for communication between different parts of the system.
+
+    All event implementations must provide:
+    - `to_dict()`: Convert the event instance to a dictionary representation
+    - `from_dict()`: Create an event instance from a dictionary
     """
 
+    @abc.abstractmethod
+    def to_dict(self) -> dict:
+        """
+        Convert the event instance to a dictionary representation.
+
+        Returns:
+            A dictionary containing all fields of the event instance.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    @abc.abstractmethod
+    def from_dict(cls, **kwargs) -> Self:
+        """
+        Create an event instance from keyword arguments.
+
+        Args:
+            **kwargs: Keyword arguments matching the event fields.
+
+        Returns:
+            A new instance of the event class.
+        """
+        raise NotImplementedError
 
-class DomainEvent(Event, frozen=True):
+
+@dataclasses.dataclass(frozen=True)
+class DCEvent(IEvent):
     """
-    The base class for domain events
+    Dataclass-based implementation of the event interface.
+
+    This class provides an event implementation using Python's frozen dataclasses.
+    Events are immutable (frozen=True) to ensure they cannot be modified after creation.
+    It's useful when you want to avoid pydantic dependency or prefer dataclasses
+    for event definitions.
+
+    Example::
+
+        @dataclasses.dataclass(frozen=True)
+        class UserCreatedEvent(DCEvent):
+            user_id: str
+            username: str
+
+        event = UserCreatedEvent(user_id="123", username="john")
+        data = event.to_dict()  # {"user_id": "123", "username": "john"}
+        restored = UserCreatedEvent.from_dict(**data)
     """
 
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        """
+        Create an event instance from keyword arguments.
+
+        Args:
+            **kwargs: Keyword arguments matching the dataclass fields.
 
-class NotificationEvent(Event, typing.Generic[PayloadT], frozen=True):
+        Returns:
+            A new instance of the event class.
+        """
+        return fromdict(cls, kwargs)
+
+    def to_dict(self) -> dict:
+        """
+        Convert the event instance to a dictionary representation.
+
+        Returns:
+            A dictionary containing all fields of the dataclass instance.
+        """
+        return asdict(self)
+
+
+class PydanticEvent(pydantic.BaseModel, IEvent, frozen=True):
     """
-    The base class for notification events
+    Pydantic-based implementation of the event interface.
+
+    This class provides an event implementation using Pydantic models with
+    frozen=True to ensure immutability. It offers data validation, serialization,
+    and other Pydantic features. This is the default event implementation used
+    by the library.
+
+    Events are immutable to ensure they cannot be modified after creation,
+    which is important for event sourcing and event-driven architectures.
+
+    Example::
+
+        class UserCreatedEvent(PydanticEvent):
+            user_id: str
+            username: str
+
+        event = UserCreatedEvent(user_id="123", username="john")
+        data = event.to_dict()  # {"user_id": "123", "username": "john"}
+        restored = UserCreatedEvent.from_dict(**data)
     """
 
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        """
+        Create an event instance from keyword arguments.
+
+        Validates and converts types (UUID strings to UUID objects,
+        datetime strings to datetime objects, nested objects like payload).
+
+        Args:
+            **kwargs: Keyword arguments matching the event fields.
+
+        Returns:
+            A new instance of the event class.
+        """
+        return cls.model_validate(kwargs)
+
+    def to_dict(self) -> dict:
+        """
+        Convert the event instance to a dictionary representation.
+
+        Returns:
+            A dictionary containing all fields of the event instance.
+        """
+        return self.model_dump(mode="python")
+
+
+Event = PydanticEvent
+
+
+class IDomainEvent(IEvent):
+    """
+    Interface for domain event objects.
+
+    Domain events represent something that happened in the domain that domain experts
+    care about. They are typically used for in-process event handling within the
+    same bounded context.
+
+    This interface extends IEvent and is implemented by DCDomainEvent and
+    PydanticDomainEvent.
+    """
+
+
+@dataclasses.dataclass(frozen=True)
+class DCDomainEvent(DCEvent, IDomainEvent):
+    """
+    Dataclass-based implementation of domain events.
+
+    Domain events represent something that happened in the domain that domain experts
+    care about. They are typically used for in-process event handling within the
+    same bounded context.
+
+    This is the dataclass implementation. For Pydantic-based implementation,
+    use PydanticDomainEvent.
+
+    Example::
+
+        @dataclasses.dataclass(frozen=True)
+        class OrderCreatedEvent(DCDomainEvent):
+            order_id: str
+            customer_id: str
+            total_amount: float
+    """
+
+
+class PydanticDomainEvent(PydanticEvent, IDomainEvent, frozen=True):
+    """
+    Pydantic-based implementation of domain events.
+
+    Domain events represent something that happened in the domain that domain experts
+    care about. They are typically used for in-process event handling within the
+    same bounded context.
+
+    This is the default domain event implementation used by the library.
+
+    Example::
+
+        class OrderCreatedEvent(PydanticDomainEvent):
+            order_id: str
+            customer_id: str
+            total_amount: float
+    """
+
+
+DomainEvent = PydanticDomainEvent
+
+
+class INotificationEvent(IEvent, typing.Generic[PayloadT]):
+    """
+    Interface for notification event objects.
+
+    Notification events are used for cross-service communication and are typically
+    published to message brokers (Kafka, RabbitMQ, etc.). They include metadata
+    like event_id, event_timestamp, event_name, and topic for routing.
+
+    This interface extends IEvent and is implemented by DCNotificationEvent and
+    PydanticNotificationEvent. It requires specific attributes that notification
+    events must have.
+
+    All notification event implementations must provide the following attributes:
+    - `event_id`: uuid.UUID - Unique identifier for the event
+    - `event_timestamp`: datetime.datetime - Timestamp when the event occurred
+    - `event_name`: str - Name of the event type
+    - `topic`: str - Message broker topic where the event should be published
+    - `payload`: PayloadT - Generic payload data of type PayloadT
+    """
+
+    # These attributes must be implemented by subclasses:
+    # - event_id: uuid.UUID - Unique identifier for the event
+    # - event_timestamp: datetime.datetime - Timestamp when the event occurred
+    # - event_name: str - Name of the event type
+    # - topic: str - Message broker topic where the event should be published
+    # - payload: PayloadT - Generic payload data of type PayloadT
+    #
+    # Type stubs for type checkers:
+    if typing.TYPE_CHECKING:
+        event_id: uuid.UUID
+        event_timestamp: datetime.datetime
+        event_name: str
+        topic: str
+        payload: PayloadT
+
+        def proto(self) -> typing.Any: ...  # Method for protobuf representation
+
+        @classmethod
+        def from_proto(cls, proto: typing.Any) -> Self: ...
+
+
+@dataclasses.dataclass(frozen=True)
+class DCNotificationEvent(
+    DCEvent,
+    INotificationEvent[PayloadT],
+    typing.Generic[PayloadT],
+):
+    """
+    Dataclass-based implementation of notification events.
+
+    Notification events are used for cross-service communication and are typically
+    published to message brokers (Kafka, RabbitMQ, etc.). They include metadata
+    like event_id, event_timestamp, event_name, and topic for routing.
+
+    This is the dataclass implementation. For Pydantic-based implementation,
+    use PydanticNotificationEvent.
+
+    Args:
+        event_id: Unique identifier for the event (auto-generated if not provided)
+        event_timestamp: Timestamp when the event occurred (auto-generated if not provided)
+        event_name: Name of the event type
+        topic: Message broker topic where the event should be published
+        payload: Generic payload data of type PayloadT
+
+    Example::
+
+        @dataclasses.dataclass(frozen=True)
+        class UserRegisteredEvent(DCNotificationEvent[dict]):
+            event_name: str = "user.registered"
+            payload: dict = dataclasses.field(default_factory=lambda: {"user_id": "123"})
+    """
+
+    event_name: str
+    payload: PayloadT
+
+    event_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
+    event_timestamp: datetime.datetime = dataclasses.field(
+        default_factory=datetime.datetime.now,
+    )
+    topic: str = dataclasses.field(default=DEFAULT_OUTPUT_TOPIC)
+
+    def proto(self) -> typing.Any:
+        """
+        Return protobuf representation of the event.
+
+        Raises:
+            NotImplementedError: This method must be implemented by subclasses
+                that need protobuf serialization.
+        """
+        raise NotImplementedError("Method not implemented")
+
+    @classmethod
+    def from_proto(cls, proto: typing.Any) -> Self:
+        """
+        Constructs event from proto event object
+
+        Raises:
+            NotImplementedError: This method must be implemented by subclasses
+                that need protobuf deserialization.
+        """
+        raise NotImplementedError("Method not implemented")
+
+    def __hash__(self) -> int:
+        """
+        Return the hash of the event based on its event_id.
+
+        Returns:
+            Hash value of the event_id.
+        """
+        return hash(self.event_id)
+
+
+class PydanticNotificationEvent(
+    PydanticEvent,
+    INotificationEvent[PayloadT],
+    typing.Generic[PayloadT],
+    frozen=True,
+):
+    """
+    Pydantic-based implementation of notification events.
+
+    Notification events are used for cross-service communication and are typically
+    published to message brokers (Kafka, RabbitMQ, etc.). They include metadata
+    like event_id, event_timestamp, event_name, and topic for routing.
+
+    This is the default notification event implementation used by the library.
+
+    Example::
+
+        class UserRegisteredEvent(PydanticNotificationEvent[dict]):
+            event_name: str = "user.registered"
+            payload: dict = pydantic.Field(default_factory=lambda: {"user_id": "123"})
+    """
+
+    payload: PayloadT
+
     event_id: uuid.UUID = pydantic.Field(default_factory=uuid.uuid4)
     event_timestamp: datetime.datetime = pydantic.Field(
         default_factory=datetime.datetime.now,
@@ -37,15 +357,37 @@ class NotificationEvent(Event, typing.Generic[PayloadT], frozen=True):
     event_name: typing.Text
     topic: typing.Text = pydantic.Field(default=DEFAULT_OUTPUT_TOPIC)
 
-    payload: PayloadT = pydantic.Field(default=None)
-
     model_config = pydantic.ConfigDict(from_attributes=True)
 
-    def proto(self):
+    def proto(self) -> typing.Any:
+        """
+        Return protobuf representation of the event.
+
+        Raises:
+            NotImplementedError: This method must be implemented by subclasses
+                that need protobuf serialization.
+        """
+        raise NotImplementedError("Method not implemented")
+
+    @classmethod
+    def from_proto(cls, proto: typing.Any) -> Self:
+        """
+        Constructs event from proto event object
+
+        Raises:
+            NotImplementedError: This method must be implemented by subclasses
+                that need protobuf deserialization.
+        """
         raise NotImplementedError("Method not implemented")
 
-    def __hash__(self):
+    def __hash__(self) -> int:
+        """
+        Return the hash of the event based on its event_id.
+
+        Returns:
+            Hash value of the event_id.
+        """
         return hash(self.event_id)
 
 
-__all__ = ("Event", "DomainEvent", "NotificationEvent")
+NotificationEvent = PydanticNotificationEvent
diff --git a/src/cqrs/events/event_emitter.py b/src/cqrs/events/event_emitter.py
index b931638..e21af7a 100644
--- a/src/cqrs/events/event_emitter.py
+++ b/src/cqrs/events/event_emitter.py
@@ -3,8 +3,10 @@
 import typing
 
 from cqrs import container as di_container, message_brokers
-from cqrs.events.event import DomainEvent, Event, NotificationEvent
+from cqrs.circuit_breaker import should_use_fallback
+from cqrs.events.event import IDomainEvent, IEvent, INotificationEvent
 from cqrs.events import event_handler, map
+from cqrs.events.fallback import EventHandlerFallback
 
 logger = logging.getLogger("cqrs")
 
@@ -13,8 +15,13 @@
 
 class EventEmitter:
     """
-    The event emitter is responsible for sending events to the according handlers or
-    to the message broker abstraction.
+    Sends events to registered handlers or to a message broker.
+
+    For :class:`~cqrs.events.event.IDomainEvent`: resolves handlers from the
+    container, runs :meth:`~cqrs.events.event_handler.EventHandler.handle`, and
+    returns follow-up events from :attr:`~cqrs.events.event_handler.EventHandler.events`.
+    For :class:`~cqrs.events.event.INotificationEvent`: sends the event to the
+    message broker (if configured) and returns an empty sequence.
     """
 
     def __init__(
@@ -23,31 +30,78 @@ def __init__(
         container: di_container.Container,
         message_broker: message_brokers.MessageBroker | None = None,
     ) -> None:
+        """
+        Initialize the event emitter.
+
+        Args:
+            event_map: Map of event types to handler types (used for domain events).
+            container: DI container to resolve handler instances.
+            message_broker: Optional broker for notification events; required
+                when emitting :class:`~cqrs.events.event.INotificationEvent`.
+
+        Example::
+
+            event_map = EventMap()
+            event_map.bind(OrderCreatedEvent, OrderCreatedEventHandler)
+            emitter = EventEmitter(
+                event_map=event_map,
+                container=di_container,
+                message_broker=kafka_broker,
+            )
+            follow_ups = await emitter.emit(OrderCreatedEvent(order_id="1"))
+        """
         self._event_map = event_map
         self._container = container
         self._message_broker = message_broker
 
     @functools.singledispatchmethod
-    async def emit(self, event: Event) -> None:
-        pass
+    async def emit(self, event: IEvent) -> typing.Sequence[IEvent]:
+        """
+        Emit an event and return follow-up events from handlers.
+
+        For unknown event types returns an empty sequence. For domain events
+        invokes all registered handlers and collects events from
+        :attr:`~cqrs.events.event_handler.EventHandler.events`. For notification
+        events sends to the message broker.
+
+        Args:
+            event: The event to emit (domain or notification).
+
+        Returns:
+            Follow-up events returned by domain event handlers; empty for
+            notification events or when no handlers are registered.
+
+        Example::
+
+            follow_ups = await emitter.emit(OrderCreatedEvent(order_id="1"))
+            for e in follow_ups:
+                await emitter.emit(e)  # or process via EventProcessor
+        """
+        return ()
 
     async def _send_to_broker(
         self,
-        event: NotificationEvent,
+        event: INotificationEvent,
     ) -> None:
         """
-        Sends event to the message broker.
+        Send a notification event to the message broker.
+
+        Args:
+            event: Notification event to send.
+
+        Raises:
+            RuntimeError: If no message broker was configured.
         """
         if not self._message_broker:
             raise RuntimeError(
-                f"To send event {event}, message_broker argument must be specified.",
+                f"To send event {event}, message broker must be specified.",
             )
 
         message = message_brokers.Message(
             message_name=type(event).__name__,
             message_id=event.event_id,
             topic=event.topic,
-            payload=event.model_dump(mode="json"),
+            payload=event.to_dict(),
         )
 
         logger.debug(
@@ -58,25 +112,83 @@ async def _send_to_broker(
 
         await self._message_broker.send_message(message)
 
-    @emit.register
-    async def _(self, event: DomainEvent) -> None:
+    async def _handle_with_fallback(
+        self,
+        event: IDomainEvent,
+        fallback_config: EventHandlerFallback,
+    ) -> typing.Sequence[IEvent]:
+        """Run primary handler with fallback on failure; return events from the handler that ran."""
+        primary: _H = await self._container.resolve(fallback_config.primary)
+        try:
+            if fallback_config.circuit_breaker is not None:
+                await fallback_config.circuit_breaker.call(
+                    fallback_config.primary,
+                    primary.handle,
+                    event,
+                )
+            else:
+                await primary.handle(event)
+            return list(primary.events)
+        except Exception as primary_error:
+            should_fallback = should_use_fallback(
+                primary_error,
+                fallback_config.circuit_breaker,
+                fallback_config.failure_exceptions,
+            )
+            if should_fallback:
+                if (
+                    fallback_config.circuit_breaker is not None
+                    and fallback_config.circuit_breaker.is_circuit_breaker_error(
+                        primary_error,
+                    )
+                ):
+                    logger.warning(
+                        "Circuit breaker open for event handler %s, switching to fallback %s",
+                        fallback_config.primary.__name__,
+                        fallback_config.fallback.__name__,
+                    )
+                else:
+                    logger.warning(
+                        "Primary event handler %s failed: %s. Switching to fallback %s.",
+                        fallback_config.primary.__name__,
+                        primary_error,
+                        fallback_config.fallback.__name__,
+                    )
+                fallback_handler: _H = await self._container.resolve(fallback_config.fallback)
+                await fallback_handler.handle(event)
+                return list(fallback_handler.events)
+            raise primary_error
+
+    @emit.register(IDomainEvent)
+    async def _(self, event: IDomainEvent) -> typing.Sequence[IEvent]:
+        """Emit domain event: run all registered handlers and return their follow-up events."""
         handlers_types = self._event_map.get(type(event), [])
         if not handlers_types:
             logger.warning(
                 "Handlers for domain event %s not found",
                 type(event).__name__,
             )
-        for handler_type in handlers_types:
-            handler: _H = await self._container.resolve(
-                handler_type,
-            )
+            return ()
+        follow_ups: list[IEvent] = []
+        for handler_item in handlers_types:
+            if isinstance(handler_item, EventHandlerFallback):
+                follow_ups.extend(
+                    await self._handle_with_fallback(event, handler_item),
+                )
+                continue
+            handler_type = handler_item
+            handler: _H = await self._container.resolve(handler_type)
             logger.debug(
                 "Handling Event(%s) via event handler(%s)",
                 type(event).__name__,
                 handler_type.__name__,
             )
             await handler.handle(event)
+            follow_ups.extend(list(handler.events))
+        return follow_ups
 
-    @emit.register
-    async def _(self, event: NotificationEvent) -> None:
+    @emit.register(INotificationEvent)
+    async def _(self, event: INotificationEvent) -> typing.Sequence[IEvent]:
+        """Emit notification event: send to message broker; no follow-ups."""
         await self._send_to_broker(event)
+        return ()
diff --git a/src/cqrs/events/event_handler.py b/src/cqrs/events/event_handler.py
index 97813c2..1759fbf 100644
--- a/src/cqrs/events/event_handler.py
+++ b/src/cqrs/events/event_handler.py
@@ -1,26 +1,59 @@
 import abc
+from collections.abc import Sequence
 import typing
 
-from cqrs.events.event import Event
+from cqrs.events.event import IEvent
 
-E = typing.TypeVar("E", bound=Event, contravariant=True)
+E = typing.TypeVar("E", bound=IEvent, contravariant=True)
 
 
 class EventHandler(abc.ABC, typing.Generic[E]):
     """
     The event handler interface.
 
-    Usage::
+    Subclasses must implement :meth:`handle`. Optionally override :attr:`events`
+    to return follow-up events emitted after handling (e.g. for multi-level
+    event chains).
 
-      class UserJoinedEventHandler(EventHandler[UserJoinedEventHandler])
-          def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
-              self._meetings_api = meetings_api
+    Example::
 
-          async def handle(self, event: UserJoinedEventHandler) -> None:
-              await self._meetings_api.notify_room(event.meeting_id, "New user joined!")
+        class UserJoinedEvent(DomainEvent):
+            meeting_id: str
+            user_id: str
 
+        class UserJoinedEventHandler(EventHandler[UserJoinedEvent]):
+            def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
+                self._meetings_api = meetings_api
+
+            async def handle(self, event: UserJoinedEvent) -> None:
+                await self._meetings_api.notify_room(
+                    event.meeting_id, "New user joined!"
+                )
     """
 
+    @property
+    def events(self) -> Sequence[IEvent]:
+        """
+        Events produced by this handler after :meth:`handle` was called.
+
+        Override in subclasses to return follow-up events that should be
+        processed by the same pipeline (e.g. domain events to emit). By default
+        returns an empty sequence.
+
+        Returns:
+            Sequence of follow-up events (e.g. new domain events) to process.
+        """
+        return ()
+
     @abc.abstractmethod
     async def handle(self, event: E) -> None:
+        """
+        Handle the given event.
+
+        Args:
+            event: The event instance to handle.
+
+        Raises:
+            NotImplementedError: Must be implemented by subclasses.
+        """
         raise NotImplementedError
diff --git a/src/cqrs/events/event_processor.py b/src/cqrs/events/event_processor.py
index b202b99..8209263 100644
--- a/src/cqrs/events/event_processor.py
+++ b/src/cqrs/events/event_processor.py
@@ -1,100 +1,143 @@
 import asyncio
 import typing
+from collections import deque
 
-from cqrs.container.protocol import Container
-from cqrs.dispatcher.event import EventDispatcher
-from cqrs.events.event import Event
+from cqrs.events.event import IEvent
 from cqrs.events.event_emitter import EventEmitter
 from cqrs.events.map import EventMap
-from cqrs.middlewares.base import MiddlewareChain
 
 
 class EventProcessor:
     """
-    Processor for handling events in parallel or sequentially.
+    Processes events in parallel or sequentially via an event emitter.
 
-    Provides methods for processing events with semaphore limits and emitting
-    them via event emitter. Can be reused across different mediators.
+    Emits events through the configured :class:`~cqrs.events.event_emitter.EventEmitter`.
+    Follow-up events returned by handlers (via :attr:`~cqrs.events.event_handler.EventHandler.events`)
+    are processed in the same pipeline: BFS in sequential mode, under the same
+    semaphore in parallel mode. Can be reused across different mediators.
+
+    Example::
+
+        event_map = EventMap()
+        event_map.bind(OrderCreatedEvent, OrderCreatedEventHandler)
+        emitter = EventEmitter(event_map=event_map, container=container)
+        processor = EventProcessor(
+            event_map=event_map,
+            event_emitter=emitter,
+            max_concurrent_event_handlers=4,
+            concurrent_event_handle_enable=True,
+        )
+        await processor.emit_events([OrderCreatedEvent(order_id="1")])
     """
 
     def __init__(
         self,
         event_map: EventMap,
-        container: Container,
         event_emitter: EventEmitter | None = None,
-        middleware_chain: MiddlewareChain | None = None,
         max_concurrent_event_handlers: int = 1,
         concurrent_event_handle_enable: bool = True,
     ) -> None:
         """
-        Initialize event processor.
+        Initialize the event processor.
 
         Args:
-            event_map: Map of event types to handler types
-            container: DI container for resolving event handlers
-            event_emitter: Optional event emitter for publishing events
-            middleware_chain: Optional middleware chain for event processing
-            max_concurrent_event_handlers: Maximum number of concurrent event handlers
-            concurrent_event_handle_enable: Whether to process events in parallel
+            event_map: Map of event types to handler types.
+            event_emitter: Emitter used to publish events; if None, :meth:`emit_events`
+                is a no-op.
+            max_concurrent_event_handlers: Semaphore limit for parallel mode.
+            concurrent_event_handle_enable: If True, process events in parallel
+                (with semaphore); if False, process sequentially (BFS over events
+                and follow-ups).
         """
         self._event_emitter = event_emitter
         self._event_map = event_map
         self._max_concurrent_event_handlers = max_concurrent_event_handlers
         self._concurrent_event_handle_enable = concurrent_event_handle_enable
         self._event_semaphore = asyncio.Semaphore(max_concurrent_event_handlers)
-        self._event_dispatcher = EventDispatcher(
-            event_map=event_map,
-            container=container,
-            middleware_chain=middleware_chain,
-        )
 
-    async def process_events(self, events: typing.List[Event]) -> None:
+    async def emit_events(self, events: typing.Sequence[IEvent]) -> None:
         """
-        Process events in parallel (with semaphore limit) or sequentially.
+        Emit all events and process follow-ups in the same pipeline.
+
+        In sequential mode, events and follow-ups are processed in BFS order.
+        In parallel mode, events are processed under the same semaphore limit;
+        as soon as any event completes, its follow-ups are queued and started
+        (FIRST_COMPLETED), without waiting for siblings. Returns when all work
+        is finished.
 
         Args:
-            events: List of events to process
+            events: Events to emit (e.g. domain events). Handlers may return
+                follow-up events via :attr:`~cqrs.events.event_handler.EventHandler.events`.
+
+        Example::
+
+            await processor.emit_events([
+                OrderCreatedEvent(order_id="1"),
+                OrderCreatedEvent(order_id="2"),
+            ])
         """
         if not events:
             return
 
+        if not self._event_emitter:
+            return
+
         if not self._concurrent_event_handle_enable:
-            # Process events sequentially
-            for event in events:
-                await self._event_dispatcher.dispatch(event)
+            # Process events sequentially (BFS: follow-ups re-queued, O(1) popleft)
+            to_process: deque[IEvent] = deque(events)
+            while to_process:
+                event = to_process.popleft()
+                follow_ups = await self._event_emitter.emit(event)
+                to_process.extend(follow_ups)
         else:
-            # Process events in parallel with semaphore limit
-            tasks = [self._process_event_with_semaphore(event) for event in events]
-            await asyncio.gather(*tasks)
+            # Process events in parallel: start follow-ups as soon as any task completes
+            # (FIRST_COMPLETED), all under the same semaphore
+            await self._emit_events_parallel_first_completed(deque(events))
 
-    async def emit_events(self, events: typing.List[Event]) -> None:
+    async def _emit_one_event(self, event: IEvent) -> typing.Sequence[IEvent]:
         """
-        Emit events via event emitter.
+        Emit one event under the semaphore. Returns follow-up events from the handler.
 
         Args:
-            events: List of events to emit
+            event: The event to emit.
+
+        Returns:
+            Follow-up events to process next, or empty sequence.
         """
         if not self._event_emitter:
-            return
-
-        while events:
-            event = events.pop()
-            await self._event_emitter.emit(event)
+            return ()
+        async with self._event_semaphore:
+            follow_ups = await self._event_emitter.emit(event)
+        if follow_ups is None:
+            return ()
+        return follow_ups
 
-    async def process_and_emit_events(self, events: typing.List[Event]) -> None:
+    async def _emit_events_parallel_first_completed(
+        self,
+        initial_events: deque[IEvent],
+    ) -> None:
         """
-        Process events and then emit them.
-
-        This is a convenience method that combines process_events and emit_events.
-
-        Args:
-            events: List of events to process and emit
+        Process events in parallel under the semaphore; as soon as any task completes,
+        its follow-up events are queued and started, without waiting for siblings.
+        Uses deque for O(1) popleft when taking the next event.
         """
-        events_copy = events.copy()
-        await self.process_events(events_copy)
-        await self.emit_events(events_copy)
-
-    async def _process_event_with_semaphore(self, event: Event) -> None:
-        """Process a single event with semaphore limit."""
-        async with self._event_semaphore:
-            await self._event_dispatcher.dispatch(event)
+        pending_events: deque[IEvent] = initial_events
+        running_tasks: set[asyncio.Task[typing.Sequence[IEvent]]] = set()
+
+        while pending_events or running_tasks:
+            # Start a task for each pending event (semaphore limits concurrency)
+            while pending_events:
+                event = pending_events.popleft()
+                task = asyncio.create_task(self._emit_one_event(event))
+                running_tasks.add(task)
+
+            if not running_tasks:
+                break
+
+            done, running_tasks = await asyncio.wait(
+                running_tasks,
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+            for task in done:
+                follow_ups = task.result()
+                pending_events.extend(follow_ups)
diff --git a/src/cqrs/events/fallback.py b/src/cqrs/events/fallback.py
new file mode 100644
index 0000000..6c5ba19
--- /dev/null
+++ b/src/cqrs/events/fallback.py
@@ -0,0 +1,92 @@
+"""Fallback wrapper for event handlers with optional circuit breaker."""
+
+import dataclasses
+import typing
+
+from cqrs.circuit_breaker import ICircuitBreaker
+from cqrs.events import event_handler
+from cqrs.generic_utils import get_generic_args_for_origin
+
+EventHandlerT = typing.Type[event_handler.EventHandler]
+
+_EVENT_HANDLER_ORIGINS: tuple[type, ...] = (event_handler.EventHandler,)
+
+
+def _event_type_name(t: type) -> str:
+    return getattr(t, "__name__", str(t))
+
+
+@dataclasses.dataclass(frozen=True)
+class EventHandlerFallback:
+    """
+    Fallback wrapper for event handlers.
+
+    When the primary handler fails (or circuit breaker is open), the fallback
+    handler is invoked. Use a separate circuit breaker instance per domain
+    (e.g. one for events) that uses the same adapter class.
+
+    Attributes:
+        primary: The primary event handler class.
+        fallback: The fallback handler class to execute if primary fails.
+        failure_exceptions: Exception types that trigger fallback; if empty, any exception.
+        circuit_breaker: Optional circuit breaker instance (e.g. AioBreakerAdapter).
+
+    Example::
+        event_cb = AioBreakerAdapter(fail_max=5, timeout_duration=60)
+        event_map.bind(
+            OrderCreatedEvent,
+            EventHandlerFallback(
+                SendEmailHandler,
+                SendEmailFallbackHandler,
+                circuit_breaker=event_cb,
+            ),
+        )
+    """
+
+    primary: EventHandlerT
+    fallback: EventHandlerT
+    failure_exceptions: tuple[type[Exception], ...] = ()
+    circuit_breaker: ICircuitBreaker | None = None
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.primary, type) or not isinstance(self.fallback, type):
+            raise TypeError(
+                "EventHandlerFallback primary and fallback must be handler classes",
+            )
+        if not issubclass(self.primary, event_handler.EventHandler):
+            raise TypeError(
+                f"EventHandlerFallback primary ({self.primary.__name__}) " "must be a subclass of EventHandler",
+            )
+        if not issubclass(self.fallback, event_handler.EventHandler):
+            raise TypeError(
+                f"EventHandlerFallback fallback ({self.fallback.__name__}) " "must be a subclass of EventHandler",
+            )
+        # Validate that primary and fallback handle the same event type
+        primary_args = get_generic_args_for_origin(
+            self.primary,
+            _EVENT_HANDLER_ORIGINS,
+            min_args=1,
+        )
+        fallback_args = get_generic_args_for_origin(
+            self.fallback,
+            _EVENT_HANDLER_ORIGINS,
+            min_args=1,
+        )
+        if primary_args is not None and fallback_args is not None:
+            # Reject TypeVar (unparameterized) so we only allow concrete types
+            if any(isinstance(a, typing.TypeVar) for a in primary_args + fallback_args):
+                raise TypeError(
+                    "EventHandlerFallback primary and fallback must be parameterized with a concrete event type "
+                    "(e.g. EventHandler[MyEvent])",
+                )
+            if primary_args[0] != fallback_args[0]:
+                raise TypeError(
+                    "EventHandlerFallback primary and fallback must handle the same event type: "
+                    f"primary {self.primary.__name__} handles {_event_type_name(primary_args[0])}, "
+                    f"fallback {self.fallback.__name__} handles {_event_type_name(fallback_args[0])}",
+                )
+        elif primary_args is None or fallback_args is None:
+            raise TypeError(
+                "EventHandlerFallback primary and fallback must be parameterized with a concrete event type "
+                "(e.g. EventHandler[MyEvent])",
+            )
diff --git a/src/cqrs/events/map.py b/src/cqrs/events/map.py
index 2d191bc..dbd5b22 100644
--- a/src/cqrs/events/map.py
+++ b/src/cqrs/events/map.py
@@ -1,29 +1,67 @@
 import typing
 
-from cqrs.events.event import Event
+from cqrs.events.event import IEvent
 from cqrs.events import event_handler
+from cqrs.events.fallback import EventHandlerFallback
 
-_KT = typing.TypeVar("_KT", bound=typing.Type[Event])
-_VT: typing.TypeAlias = typing.List[typing.Type[event_handler.EventHandler]]
+_KT = typing.TypeVar("_KT", bound=typing.Type[IEvent])
+_HandlerItem = typing.Type[event_handler.EventHandler] | EventHandlerFallback
+_VT: typing.TypeAlias = typing.List[_HandlerItem]
 
 
 class EventMap(typing.Dict[_KT, _VT]):
+    """
+    Registry mapping event types to one or more handler types or fallbacks.
+
+    Use :meth:`bind` to register handlers for an event type. Multiple handlers
+    can be bound to the same event; all will be invoked when the event is emitted.
+    Handlers can be plain types or :class:`~cqrs.events.fallback.EventHandlerFallback`.
+    Keys cannot be overwritten or deleted.
+
+    Example::
+
+        event_map = EventMap()
+        event_map.bind(OrderCreatedEvent, OrderCreatedEventHandler)
+        event_map.bind(OrderCreatedEvent, SendEmailHandler)  # second handler for same event
+        event_map.bind(OrderCreatedEvent, EventHandlerFallback(PrimaryHandler, FallbackHandler, circuit_breaker=cb))
+    """
+
     def bind(
         self,
         event_type: _KT,
-        handler_type: typing.Type[event_handler.EventHandler],
+        handler_type: _HandlerItem,
     ) -> None:
+        """
+        Register a handler type or EventHandlerFallback for an event type.
+
+        If the event type is new, creates a list with this handler. If the event
+        type already exists, appends the handler (duplicates are rejected).
+
+        Args:
+            event_type: Event class (e.g. :class:`OrderCreatedEvent`).
+            handler_type: Handler class or :class:`~cqrs.events.fallback.EventHandlerFallback`.
+
+        Raises:
+            KeyError: If the same handler type or fallback is already bound to this event type.
+        """
         if event_type not in self:
             self[event_type] = [handler_type]
         else:
             if handler_type in self[event_type]:
-                raise KeyError(f"{handler_type} already bind to {event_type}")
+                raise KeyError(f"{handler_type} already bound to {event_type}")
             self[event_type].append(handler_type)
 
     def __setitem__(self, __key: _KT, __value: _VT) -> None:
+        """
+        Set handler list for an event type (only if key is not already present).
+
+        Raises:
+            KeyError: If the event type is already in the registry.
+        """
         if __key in self:
             raise KeyError(f"{__key} already exists in registry")
         super().__setitem__(__key, __value)
 
     def __delitem__(self, __key_: _KT) -> typing.NoReturn:
+        """Deletion is not supported; raises TypeError."""
         raise TypeError(f"{self.__class__.__name__} has no delete method")
diff --git a/src/cqrs/generic_utils.py b/src/cqrs/generic_utils.py
new file mode 100644
index 0000000..438359b
--- /dev/null
+++ b/src/cqrs/generic_utils.py
@@ -0,0 +1,43 @@
+"""Shared utilities for extracting generic type parameters from handler classes."""
+
+import typing
+
+
+def get_generic_args_for_origin(
+    klass: type,
+    origin_classes: tuple[type, ...],
+    min_args: int = 1,
+) -> tuple[type, ...] | None:
+    """
+    Extract generic type arguments from a class that inherits from a Generic base.
+
+    Walks __orig_bases__ and __bases__ to find the first base whose origin is
+    one of the given origin_classes, then returns typing.get_args(base).
+
+    Args:
+        klass: The handler class (e.g. a subclass of RequestHandler[Req, Res]).
+        origin_classes: Tuple of possible origin classes (e.g. (RequestHandler, StreamingRequestHandler)).
+        min_args: Minimum number of type arguments required to consider the result valid.
+
+    Returns:
+        Tuple of type arguments (e.g. (ReqT, ResT) or (ET,)), or None if not found
+        or if the base has fewer than min_args concrete arguments.
+    """
+    # Prefer __orig_bases__ (Python 3.12+ / generic subclass)
+    orig_bases = getattr(klass, "__orig_bases__", ())
+    for base in orig_bases:
+        origin = typing.get_origin(base)
+        if origin in origin_classes:
+            args = typing.get_args(base)
+            if len(args) >= min_args:
+                return args
+
+    # Fallback: __bases__ may contain the parameterized base
+    for base in klass.__bases__:
+        origin = typing.get_origin(base)
+        if origin in origin_classes:
+            args = typing.get_args(base)
+            if len(args) >= min_args:
+                return args
+
+    return None
diff --git a/src/cqrs/mediator.py b/src/cqrs/mediator.py
index b1295e8..71c0d60 100644
--- a/src/cqrs/mediator.py
+++ b/src/cqrs/mediator.py
@@ -6,20 +6,20 @@
 from cqrs.dispatcher.request import RequestDispatcher
 from cqrs.dispatcher.saga import SagaDispatcher
 from cqrs.dispatcher.streaming import StreamingRequestDispatcher
-from cqrs.events.event import Event
+from cqrs.events.event import IEvent
 from cqrs.events.event_emitter import EventEmitter
 from cqrs.events.event_processor import EventProcessor
 from cqrs.events.map import EventMap
 from cqrs.middlewares.base import MiddlewareChain
 from cqrs.requests.map import RequestMap, SagaMap
-from cqrs.requests.request import Request
-from cqrs.response import Response
+from cqrs.requests.request import IRequest
+from cqrs.response import IResponse
 from cqrs.saga.models import SagaContext
 from cqrs.saga.step import SagaStepResult
 from cqrs.saga.storage.memory import MemorySagaStorage
 from cqrs.saga.storage.protocol import ISagaStorage
 
-_ResponseT = typing.TypeVar("_ResponseT", Response, None, covariant=True)
+_ResponseT = typing.TypeVar("_ResponseT", IResponse, None, covariant=True)
 
 
 class RequestMediator:
@@ -71,9 +71,7 @@ def __init__(
     ) -> None:
         self._event_processor = EventProcessor(
             event_map=event_map or EventMap(),
-            container=container,
             event_emitter=event_emitter,
-            middleware_chain=middleware_chain,
             max_concurrent_event_handlers=max_concurrent_event_handlers,
             concurrent_event_handle_enable=concurrent_event_handle_enable,
         )
@@ -83,7 +81,7 @@ def __init__(
             middleware_chain=middleware_chain,  # type: ignore
         )
 
-    async def send(self, request: Request) -> _ResponseT:
+    async def send(self, request: IRequest) -> _ResponseT:
         """
         Send a request and return the response.
 
@@ -94,12 +92,7 @@ async def send(self, request: Request) -> _ResponseT:
         Note: TypeVar usage here is intentional for type inference purposes.
         """
         dispatch_result = await self._dispatcher.dispatch(request)
-
-        if dispatch_result.events:
-            await self._event_processor.process_and_emit_events(
-                dispatch_result.events.copy(),
-            )
-
+        await self._event_processor.emit_events(dispatch_result.events)
         return dispatch_result.response
 
 
@@ -133,7 +126,7 @@ def __init__(
             middleware_chain=middleware_chain,  # type: ignore
         )
 
-    async def send(self, event: Event) -> None:
+    async def send(self, event: IEvent) -> None:
         await self._dispatcher.dispatch(event)
 
 
@@ -179,15 +172,11 @@ def __init__(
         max_concurrent_event_handlers: int = 1,
         concurrent_event_handle_enable: bool = True,
         *,
-        dispatcher_type: typing.Type[
-            StreamingRequestDispatcher
-        ] = StreamingRequestDispatcher,
+        dispatcher_type: typing.Type[StreamingRequestDispatcher] = StreamingRequestDispatcher,
     ) -> None:
         self._event_processor = EventProcessor(
             event_map=event_map or EventMap(),
-            container=container,
             event_emitter=event_emitter,
-            middleware_chain=middleware_chain,
             max_concurrent_event_handlers=max_concurrent_event_handlers,
             concurrent_event_handle_enable=concurrent_event_handle_enable,
         )
@@ -197,13 +186,14 @@ def __init__(
             middleware_chain=middleware_chain,  # type: ignore
         )
 
-    async def stream(
+    def stream(
         self,
-        request: Request,
-    ) -> typing.AsyncIterator[Response | None]:
+        request: IRequest,
+    ) -> typing.AsyncIterator[IResponse | None]:
         """
         Stream results from a generator-based handler.
 
+        Called without await; returns an AsyncIterator consumed with async for.
         After each yield from the handler:
         1. Events are processed (in parallel with semaphore limit or sequentially
            depending on concurrent_event_handle_enable) via event dispatcher
@@ -212,11 +202,14 @@ async def stream(
 
         The generator continues until StopIteration is raised.
         """
+        return self._stream_impl(request)
+
+    async def _stream_impl(
+        self,
+        request: IRequest,
+    ) -> typing.AsyncIterator[IResponse | None]:
         async for dispatch_result in self._dispatcher.dispatch(request):
-            if dispatch_result.events:
-                await self._event_processor.process_and_emit_events(
-                    dispatch_result.events.copy(),
-                )
+            await self._event_processor.emit_events(dispatch_result.events)
 
             yield dispatch_result.response
 
@@ -272,9 +265,7 @@ def __init__(
     ) -> None:
         self._event_processor = EventProcessor(
             event_map=event_map or EventMap(),
-            container=container,
             event_emitter=event_emitter,
-            middleware_chain=middleware_chain,
             max_concurrent_event_handlers=max_concurrent_event_handlers,
             concurrent_event_handle_enable=concurrent_event_handle_enable,
         )
@@ -288,7 +279,7 @@ def __init__(
             compensation_retry_backoff=compensation_retry_backoff,  # type: ignore
         )
 
-    async def stream(
+    def stream(
         self,
         context: SagaContext,
         saga_id: uuid.UUID | None = None,
@@ -296,6 +287,7 @@ async def stream(
         """
         Stream results from saga execution.
 
+        Called without await; returns an AsyncIterator consumed with async for.
         After each step execution:
         1. Events are processed (in parallel with semaphore limit or sequentially
            depending on concurrent_event_handle_enable) via event dispatcher
@@ -312,13 +304,16 @@ async def stream(
         Yields:
             SagaStepResult
         """
+        return self._stream_impl(context, saga_id=saga_id)
+
+    async def _stream_impl(
+        self,
+        context: SagaContext,
+        saga_id: uuid.UUID | None = None,
+    ) -> typing.AsyncIterator[SagaStepResult]:
         async for dispatch_result in self._dispatcher.dispatch(
             context,
             saga_id=saga_id,
         ):
-            if dispatch_result.events:
-                await self._event_processor.process_and_emit_events(
-                    dispatch_result.events.copy(),
-                )
-
+            await self._event_processor.emit_events(dispatch_result.events)
             yield dispatch_result.step_result
diff --git a/src/cqrs/message_brokers/amqp.py b/src/cqrs/message_brokers/amqp.py
index 28e0063..311138b 100644
--- a/src/cqrs/message_brokers/amqp.py
+++ b/src/cqrs/message_brokers/amqp.py
@@ -8,7 +8,12 @@
 
 
 class AMQPMessageBroker(protocol.MessageBroker):
-    def __init__(self, publisher: adapters_protocol.AMQPPublisher, exchange_name: str, pika_log_level: str = "ERROR"):
+    def __init__(
+        self,
+        publisher: adapters_protocol.AMQPPublisher,
+        exchange_name: str,
+        pika_log_level: str = "ERROR",
+    ):
         self.publisher = publisher
         self.exchange_name = exchange_name
         logging.getLogger("aiormq").setLevel(pika_log_level)
@@ -17,6 +22,6 @@ def __init__(self, publisher: adapters_protocol.AMQPPublisher, exchange_name: st
     async def send_message(self, message: protocol.Message) -> None:
         await self.publisher.publish(
             message=aio_pika.Message(body=orjson.dumps(message.payload)),
-            exchange_name=self.exchange_name,
             queue_name=message.topic,
+            exchange_name=self.exchange_name,
         )
diff --git a/src/cqrs/message_brokers/protocol.py b/src/cqrs/message_brokers/protocol.py
index 1423280..744fd5b 100644
--- a/src/cqrs/message_brokers/protocol.py
+++ b/src/cqrs/message_brokers/protocol.py
@@ -1,15 +1,35 @@
 import abc
+import dataclasses
 import typing
 import uuid
+from dataclass_wizard import asdict
 
-import pydantic
 
+@dataclasses.dataclass
+class Message:
+    """
+    Internal message structure for message broker communication.
+
+    Args:
+        message_name: Name of the message type
+        message_id: Unique identifier for the message (auto-generated if not provided)
+        topic: Message broker topic where the message should be sent
+        payload: Message payload data
+    """
 
-class Message(pydantic.BaseModel):
-    message_name: typing.Text = pydantic.Field()
-    message_id: uuid.UUID = pydantic.Field(default_factory=uuid.uuid4)
+    message_name: typing.Text
     topic: typing.Text
     payload: typing.Any
+    message_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
+
+    def to_dict(self) -> dict[str, typing.Any]:
+        """
+        Convert the message instance to a dictionary representation.
+
+        Returns:
+            A dictionary containing all fields of the message instance.
+        """
+        return asdict(self)
 
 
 class MessageBroker(abc.ABC):
diff --git a/src/cqrs/middlewares/base.py b/src/cqrs/middlewares/base.py
index 1e4295b..60856f5 100644
--- a/src/cqrs/middlewares/base.py
+++ b/src/cqrs/middlewares/base.py
@@ -2,7 +2,7 @@
 import typing
 
 from cqrs.saga.models import SagaContext
-from cqrs.types import ReqT, ResT
+from cqrs.requests.request import ReqT, ResT
 
 HandleType = typing.Callable[[ReqT], typing.Awaitable[ResT] | ResT]
 
diff --git a/src/cqrs/middlewares/logging.py b/src/cqrs/middlewares/logging.py
index f54f69b..d1750b2 100644
--- a/src/cqrs/middlewares/logging.py
+++ b/src/cqrs/middlewares/logging.py
@@ -2,29 +2,32 @@
 
 from cqrs.middlewares import base
 from cqrs.middlewares.base import HandleType
-from cqrs.requests.request import Request
-from cqrs.response import Response
+from cqrs.requests.request import IRequest
+from cqrs.response import IResponse
 
 logger = logging.getLogger("cqrs")
 
 
 class LoggingMiddleware(base.Middleware):
-    async def __call__(self, request: Request, handle: HandleType) -> Response | None:
+    async def __call__(self, request: IRequest, handle: HandleType) -> IResponse | None:
         logger.debug(
             "Handle %s request",
             type(request).__name__,
             extra={
-                "request_json_fields": {"request": request.model_dump(mode="json")},
+                "request_json_fields": {"request": request.to_dict()},
                 "to_mask": True,
             },
         )
         resp = await handle(request)
+        resp_dict = {}
+        if resp:
+            resp_dict = resp.to_dict()
         logger.debug(
             "Request %s handled",
             type(request).__name__,
             extra={
                 "request_json_fields": {
-                    "response": resp.model_dump(mode="json") if resp else {},
+                    "response": resp_dict,
                 },
                 "to_mask": True,
             },
diff --git a/src/cqrs/outbox/map.py b/src/cqrs/outbox/map.py
index 4b52834..5cb41d4 100644
--- a/src/cqrs/outbox/map.py
+++ b/src/cqrs/outbox/map.py
@@ -1,16 +1,16 @@
 import typing
 
-from cqrs.events.event import NotificationEvent
+from cqrs.events.event import INotificationEvent
 
 
 class OutboxedEventMap:
-    _registry: typing.Dict[typing.Text, typing.Type[NotificationEvent]] = {}
+    _registry: typing.Dict[typing.Text, typing.Type[INotificationEvent]] = {}
 
     @classmethod
     def register(
         cls,
         event_name: typing.Text,
-        event_type: typing.Type[NotificationEvent],
+        event_type: typing.Type[INotificationEvent],
     ) -> None:
         if event_name in cls._registry:
             raise KeyError(f"Event with {event_name} already registered")
@@ -20,5 +20,5 @@ def register(
     def get(
         cls,
         event_name: typing.Text,
-    ) -> typing.Type[NotificationEvent] | None:
+    ) -> typing.Type[INotificationEvent] | None:
         return cls._registry.get(event_name)
diff --git a/src/cqrs/outbox/mock.py b/src/cqrs/outbox/mock.py
index 1d5329d..6375d27 100644
--- a/src/cqrs/outbox/mock.py
+++ b/src/cqrs/outbox/mock.py
@@ -16,7 +16,7 @@ async def __aenter__(self) -> typing.Dict:
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         pass
 
-    def add(self, event: cqrs.NotificationEvent) -> None:
+    def add(self, event: cqrs.INotificationEvent) -> None:
         MockOutboxedEventRepository.COUNTER += 1
         self.session[MockOutboxedEventRepository.COUNTER] = repository.OutboxedEvent(
             id=MockOutboxedEventRepository.COUNTER,
@@ -31,9 +31,7 @@ async def get_many(
         topic: typing.Text | None = None,
     ) -> typing.List[repository.OutboxedEvent]:
         return list(
-            filter(lambda e: topic == e.topic, self.session.values())
-            if topic
-            else list(self.session.values()),
+            filter(lambda e: topic == e.topic, self.session.values()) if topic else list(self.session.values()),
         )
 
     async def update_status(
diff --git a/src/cqrs/outbox/repository.py b/src/cqrs/outbox/repository.py
index b6f7029..474b864 100644
--- a/src/cqrs/outbox/repository.py
+++ b/src/cqrs/outbox/repository.py
@@ -1,23 +1,59 @@
 import abc
+import dataclasses
 import enum
+import sys
 import typing
 
-import pydantic
-
 import cqrs
-from cqrs.events.event import NotificationEvent
+from cqrs.events.event import INotificationEvent
+
+if sys.version_info >= (3, 11):
+    StrEnum = enum.StrEnum  # novm
+else:
+    # For Python 3.10 compatibility, use regular Enum with string values
+    class StrEnum(str, enum.Enum):  # type: ignore[misc]
+        """Compatible StrEnum for Python 3.10."""
+
+        def __str__(self) -> str:
+            return self.value
 
 
-class EventStatus(enum.StrEnum):
+class EventStatus(StrEnum):
     NEW = "new"
     PRODUCED = "produced"
     NOT_PRODUCED = "not_produced"
 
 
-class OutboxedEvent(pydantic.BaseModel, frozen=True):
-    id: pydantic.PositiveInt
-    event: cqrs.NotificationEvent
-    topic: typing.Text
+@dataclasses.dataclass(frozen=True)
+class OutboxedEvent:
+    """
+    Outboxed event dataclass.
+
+    Outboxed events represent notification events that are stored in an outbox
+    pattern for reliable message delivery. They include metadata about the event
+    and its processing status.
+
+    This is an internal data structure used by the outbox pattern implementation.
+
+    Args:
+        id: Unique identifier for the outboxed event
+        event: The notification event being stored
+        topic: Message broker topic where the event should be published
+        status: Current processing status of the event
+
+    Example::
+
+        outboxed_event = OutboxedEvent(
+            id=1,
+            event=notification_event,
+            topic="user.events",
+            status=EventStatus.NEW
+        )
+    """
+
+    id: int
+    event: cqrs.INotificationEvent
+    topic: str
     status: EventStatus
 
 
@@ -25,7 +61,7 @@ class OutboxedEventRepository(abc.ABC):
     @abc.abstractmethod
     def add(
         self,
-        event: NotificationEvent,
+        event: INotificationEvent,
     ) -> None:
         """Add an event to the repository."""
 
@@ -52,3 +88,10 @@ async def commit(self):
     @abc.abstractmethod
     async def rollback(self):
         pass
+
+
+__all__ = (
+    "EventStatus",
+    "OutboxedEvent",
+    "OutboxedEventRepository",
+)
diff --git a/src/cqrs/outbox/sqlalchemy.py b/src/cqrs/outbox/sqlalchemy.py
index aeb126f..99160ac 100644
--- a/src/cqrs/outbox/sqlalchemy.py
+++ b/src/cqrs/outbox/sqlalchemy.py
@@ -1,18 +1,29 @@
+import datetime
 import logging
 import typing
 
 import dotenv
 import orjson
-import sqlalchemy
-from sqlalchemy import func
-from sqlalchemy.dialects import mysql
-from sqlalchemy.ext.asyncio import session as sql_session
-from sqlalchemy.orm import DeclarativeMeta, registry
-
 import cqrs
+import uuid
 from cqrs import compressors
 from cqrs.outbox import map, repository
 
+try:
+    import sqlalchemy
+
+    from sqlalchemy import func
+    from sqlalchemy.orm import Mapped, mapped_column, DeclarativeMeta, registry
+    from sqlalchemy.ext.asyncio import session as sql_session
+    from sqlalchemy.dialects import postgresql
+except ImportError:
+    raise ImportError(
+        "You are trying to use SQLAlchemy outbox implementation, "
+        "but 'sqlalchemy' is not installed. "
+        "Please install it using: pip install python-cqrs[sqlalchemy]",
+    ) from None
+
+
 Base = registry().generate_base()
 
 logger = logging.getLogger(__name__)
@@ -24,6 +35,39 @@
 MAX_FLUSH_COUNTER_VALUE = 5
 
 
+class BinaryUUID(sqlalchemy.TypeDecorator):
+    """Stores the UUID as a native UUID in Postgres and as BINARY(16) in other databases (MySQL)."""
+
+    impl = sqlalchemy.BINARY(16)
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect):
+        if dialect.name == "postgresql":
+            return dialect.type_descriptor(postgresql.UUID())
+        else:
+            return dialect.type_descriptor(sqlalchemy.BINARY(16))
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return value
+        if isinstance(value, str):
+            value = uuid.UUID(value)
+        if dialect.name == "postgresql":
+            return value  # asyncpg works with uuid.UUID
+        if isinstance(value, uuid.UUID):
+            return value.bytes  # For MySQL return 16 bytes
+        return value
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return value
+        if dialect.name == "postgresql":
+            return value  # asyncpg return uuid.UUID
+        if isinstance(value, bytes):
+            return uuid.UUID(bytes=value)  # From MySQL got bytes, make UUID
+        return value
+
+
 class OutboxModel(Base):
     __tablename__ = DEFAULT_OUTBOX_TABLE_NAME
 
@@ -34,64 +78,61 @@ class OutboxModel(Base):
             name="event_id_unique_index",
         ),
     )
-    id = sqlalchemy.Column(
-        sqlalchemy.BigInteger(),
+    id: Mapped[int] = mapped_column(
+        sqlalchemy.BigInteger,
         sqlalchemy.Identity(),
         primary_key=True,
         nullable=False,
         autoincrement=True,
         comment="Identity",
     )
-    event_id = sqlalchemy.Column(
-        sqlalchemy.Uuid,
+    event_id: Mapped[uuid.UUID] = mapped_column(
+        BinaryUUID,
         nullable=False,
         comment="Event idempotency id",
     )
-    event_id_bin = sqlalchemy.Column(
+    event_id_bin: Mapped[bytes] = mapped_column(
         sqlalchemy.BINARY(16),
         nullable=False,
         comment="Event idempotency id in 16 bit presentation",
     )
-    event_status = sqlalchemy.Column(
+    event_status: Mapped[repository.EventStatus] = mapped_column(
         sqlalchemy.Enum(repository.EventStatus),
         nullable=False,
         default=repository.EventStatus.NEW,
         comment="Event producing status",
     )
-    flush_counter = sqlalchemy.Column(
-        sqlalchemy.SmallInteger(),
+    flush_counter: Mapped[int] = mapped_column(
+        sqlalchemy.SmallInteger,
         nullable=False,
         default=0,
         comment="Event producing flush counter",
     )
-    event_name = sqlalchemy.Column(
+    event_name: Mapped[typing.Text] = mapped_column(
         sqlalchemy.String(255),
         nullable=False,
         comment="Event name",
     )
-    topic = sqlalchemy.Column(
+    topic: Mapped[typing.Text] = mapped_column(
         sqlalchemy.String(255),
         nullable=False,
         comment="Event topic",
         default="",
     )
-    created_at = sqlalchemy.Column(
+    created_at: Mapped[datetime.datetime] = mapped_column(
         sqlalchemy.DateTime,
         nullable=False,
         server_default=func.now(),
         comment="Event creation timestamp",
     )
-    payload = sqlalchemy.Column(
-        mysql.BLOB,
+    payload: Mapped[bytes] = mapped_column(
+        sqlalchemy.LargeBinary,
         nullable=False,
-        default={},
         comment="Event payload",
     )
 
     def row_to_dict(self) -> typing.Dict[typing.Text, typing.Any]:
-        return {
-            column.name: getattr(self, column.name) for column in self.__table__.columns
-        }
+        return {column.name: getattr(self, column.name) for column in self.__table__.columns}
 
     @classmethod
     def get_batch_query(
@@ -132,9 +173,7 @@ def update_status_query(
         if status == repository.EventStatus.NOT_PRODUCED:
             values["flush_counter"] += 1
 
-        return (
-            sqlalchemy.update(cls).where(cls.id == outboxed_event_id).values(**values)
-        )
+        return sqlalchemy.update(cls).where(cls.id == outboxed_event_id).values(**values)
 
     @classmethod
     def status_sorting_case(cls) -> sqlalchemy.Case:
@@ -160,7 +199,7 @@ def __init__(
 
     def add(
         self,
-        event: cqrs.NotificationEvent,
+        event: cqrs.INotificationEvent,
     ) -> None:
         registered_event = map.OutboxedEventMap.get(event.event_name)
         if registered_event is None:
@@ -171,14 +210,14 @@ def add(
                 f"Event type {type(event)} does not match registered event type {registered_event}",
             )
 
-        bytes_payload = orjson.dumps(event.model_dump(mode="json"))
+        bytes_payload = orjson.dumps(event.to_dict())
         if self._compressor is not None:
             bytes_payload = self._compressor.compress(bytes_payload)
 
         self.session.add(
             OutboxModel(
                 event_id=event.event_id,
-                event_id_bin=func.UUID_TO_BIN(event.event_id),
+                event_id_bin=event.event_id.bytes,
                 event_name=event.event_name,
                 created_at=event.event_timestamp,
                 payload=bytes_payload,
@@ -191,17 +230,19 @@ def _process_events(self, model: OutboxModel) -> repository.OutboxedEvent | None
 
         event_model = map.OutboxedEventMap.get(event_dict["event_name"])
         if event_model is None:
-            return
+            return None
 
         if self._compressor is not None:
             event_dict["payload"] = self._compressor.decompress(event_dict["payload"])
-        event_dict["payload"] = orjson.loads(event_dict["payload"])
+        event_payload_dict = orjson.loads(event_dict["payload"])
 
+        # Use from_dict interface method for validation and type conversion
+        # This works through the interface without exposing implementation details
         return repository.OutboxedEvent(
             id=event_dict["id"],
             topic=event_dict["topic"],
             status=event_dict["event_status"],
-            event=event_model.model_validate(event_dict["payload"]),
+            event=event_model.from_dict(**event_payload_dict),
         )
 
     async def get_many(
@@ -210,9 +251,7 @@ async def get_many(
         topic: typing.Text | None = None,
     ) -> typing.List[repository.OutboxedEvent]:
         events: typing.Sequence[OutboxModel] = (
-            (await self.session.execute(OutboxModel.get_batch_query(batch_size, topic)))
-            .scalars()
-            .all()
+            (await self.session.execute(OutboxModel.get_batch_query(batch_size, topic))).scalars().all()
         )
 
         result = []
diff --git a/src/cqrs/producer.py b/src/cqrs/producer.py
index 47bb7b0..f1dbaf8 100644
--- a/src/cqrs/producer.py
+++ b/src/cqrs/producer.py
@@ -37,7 +37,7 @@ async def send_message(self, event: repository_protocol.OutboxedEvent):
                     message_name=event.event.event_name,
                     message_id=event.event.event_id,
                     topic=event.topic,
-                    payload=event.event.model_dump(),
+                    payload=event.event.to_dict(),
                 ),
             )
         except Exception as error:
@@ -48,12 +48,12 @@ async def send_message(self, event: repository_protocol.OutboxedEvent):
                 return
             await self.repository.update_status(
                 event.id,
-                repository_protocol.EventStatus.NOT_PRODUCED,
+                repository_protocol.EventStatus.NOT_PRODUCED,  # type: ignore[arg-type]
             )
         else:
             if not self.repository:
                 return
             await self.repository.update_status(
                 event.id,
-                repository_protocol.EventStatus.PRODUCED,
+                repository_protocol.EventStatus.PRODUCED,  # type: ignore[arg-type]
             )
diff --git a/src/cqrs/requests/bootstrap.py b/src/cqrs/requests/bootstrap.py
index 60a3354..916f432 100644
--- a/src/cqrs/requests/bootstrap.py
+++ b/src/cqrs/requests/bootstrap.py
@@ -220,10 +220,12 @@ def bootstrap(
     middlewares_list: typing.List[mediator_middlewares.Middleware] = list(
         middlewares or [],
     )
+    if not any(isinstance(m, logging_middleware.LoggingMiddleware) for m in middlewares_list):
+        middlewares_list.append(logging_middleware.LoggingMiddleware())
     return setup_mediator(
         event_emitter,
         container,
-        middlewares=middlewares_list + [logging_middleware.LoggingMiddleware()],
+        middlewares=middlewares_list,
         commands_mapper=commands_mapper,
         queries_mapper=queries_mapper,
         event_map=event_emitter._event_map,
@@ -232,6 +234,7 @@ def bootstrap(
     )
 
 
+@overload
 def setup_streaming_mediator(
     event_emitter: events.EventEmitter,
     container: di_container_impl.DIContainer,
@@ -241,6 +244,31 @@ def setup_streaming_mediator(
     domain_events_mapper: typing.Callable[[events.EventMap], None] | None = None,
     max_concurrent_event_handlers: int = 10,
     concurrent_event_handle_enable: bool = True,
+) -> cqrs.StreamingRequestMediator: ...
+
+
+@overload
+def setup_streaming_mediator(
+    event_emitter: events.EventEmitter,
+    container: CQRSContainer,
+    middlewares: typing.Iterable[mediator_middlewares.Middleware],
+    commands_mapper: typing.Callable[[RequestMap], None] | None = None,
+    queries_mapper: typing.Callable[[RequestMap], None] | None = None,
+    domain_events_mapper: typing.Callable[[events.EventMap], None] | None = None,
+    max_concurrent_event_handlers: int = 10,
+    concurrent_event_handle_enable: bool = True,
+) -> cqrs.StreamingRequestMediator: ...
+
+
+def setup_streaming_mediator(
+    event_emitter: events.EventEmitter,
+    container: di_container_impl.DIContainer | CQRSContainer,
+    middlewares: typing.Iterable[mediator_middlewares.Middleware],
+    commands_mapper: typing.Callable[[RequestMap], None] | None = None,
+    queries_mapper: typing.Callable[[RequestMap], None] | None = None,
+    domain_events_mapper: typing.Callable[[events.EventMap], None] | None = None,
+    max_concurrent_event_handlers: int = 10,
+    concurrent_event_handle_enable: bool = True,
 ) -> cqrs.StreamingRequestMediator:
     requests_mapper = RequestMap()
     if commands_mapper:
@@ -268,6 +296,7 @@ def setup_streaming_mediator(
     )
 
 
+@overload
 def bootstrap_streaming(
     di_container: di.Container,
     message_broker: protocol.MessageBroker | None = None,
@@ -278,6 +307,33 @@ def bootstrap_streaming(
     on_startup: typing.List[typing.Callable[[], None]] | None = None,
     max_concurrent_event_handlers: int = 10,
     concurrent_event_handle_enable: bool = False,
+) -> cqrs.StreamingRequestMediator: ...
+
+
+@overload
+def bootstrap_streaming(
+    di_container: CQRSContainer,
+    message_broker: protocol.MessageBroker | None = None,
+    middlewares: typing.Sequence[mediator_middlewares.Middleware] | None = None,
+    commands_mapper: typing.Callable[[RequestMap], None] | None = None,
+    domain_events_mapper: typing.Callable[[events.EventMap], None] | None = None,
+    queries_mapper: typing.Callable[[RequestMap], None] | None = None,
+    on_startup: typing.List[typing.Callable[[], None]] | None = None,
+    max_concurrent_event_handlers: int = 10,
+    concurrent_event_handle_enable: bool = False,
+) -> cqrs.StreamingRequestMediator: ...
+
+
+def bootstrap_streaming(
+    di_container: di.Container | CQRSContainer,
+    message_broker: protocol.MessageBroker | None = None,
+    middlewares: typing.Sequence[mediator_middlewares.Middleware] | None = None,
+    commands_mapper: typing.Callable[[RequestMap], None] | None = None,
+    domain_events_mapper: typing.Callable[[events.EventMap], None] | None = None,
+    queries_mapper: typing.Callable[[RequestMap], None] | None = None,
+    on_startup: typing.List[typing.Callable[[], None]] | None = None,
+    max_concurrent_event_handlers: int = 10,
+    concurrent_event_handle_enable: bool = False,
 ) -> cqrs.StreamingRequestMediator:
     if message_broker is None:
         message_broker = DEFAULT_MESSAGE_BROKER
@@ -287,8 +343,15 @@ def bootstrap_streaming(
     for fun in on_startup:
         fun()
 
-    container = di_container_impl.DIContainer()
-    container.attach_external_container(di_container)
+    # If the provided container is a container implemented using di package,
+    # we need to wrap it into our own container
+    if isinstance(di_container, di.Container):
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di_container)
+
+    # Otherwise, we can use the provided container directly
+    else:
+        container = di_container
 
     event_emitter = setup_event_emitter(
         container,
@@ -298,10 +361,12 @@ def bootstrap_streaming(
     middlewares_list: typing.List[mediator_middlewares.Middleware] = list(
         middlewares or [],
     )
+    if not any(isinstance(m, logging_middleware.LoggingMiddleware) for m in middlewares_list):
+        middlewares_list.append(logging_middleware.LoggingMiddleware())
     return setup_streaming_mediator(
         event_emitter,
         container,
-        middlewares=middlewares_list + [logging_middleware.LoggingMiddleware()],
+        middlewares=middlewares_list,
         commands_mapper=commands_mapper,
         queries_mapper=queries_mapper,
         domain_events_mapper=domain_events_mapper,
diff --git a/src/cqrs/requests/cor_request_handler.py b/src/cqrs/requests/cor_request_handler.py
index e6b0adb..c102fe1 100644
--- a/src/cqrs/requests/cor_request_handler.py
+++ b/src/cqrs/requests/cor_request_handler.py
@@ -4,8 +4,8 @@
 import functools
 import typing
 
-from cqrs.events.event import Event
-from cqrs.types import ReqT, ResT
+from cqrs.events.event import IEvent
+from cqrs.requests.request import ReqT, ResT
 
 
 class CORRequestHandler(abc.ABC, typing.Generic[ReqT, ResT]):
@@ -20,7 +20,7 @@ class CORRequestHandler(abc.ABC, typing.Generic[ReqT, ResT]):
       class AuthenticationHandler(CORRequestHandler[LoginCommand, None]):
           def __init__(self, auth_service: AuthServiceProtocol) -> None:
               self._auth_service = auth_service
-              self.events: typing.List[Event] = []
+              self.events: typing.List[IEvent] = []
 
           async def handle(self, request: LoginCommand) -> None | None:
               if self._auth_service.can_authenticate(request):
@@ -46,9 +46,14 @@ async def next(self, request: ReqT) -> ResT | None:
         return typing.cast(ResT, None)
 
     @property
-    @abc.abstractmethod
-    def events(self) -> typing.List[Event]:
-        raise NotImplementedError
+    def events(self) -> typing.Sequence[IEvent]:
+        """
+        Events produced by this handler after :meth:`handle` was called.
+
+        Override in subclasses to return follow-up events. By default returns
+        an empty sequence.
+        """
+        return ()
 
     @abc.abstractmethod
     async def handle(self, request: ReqT) -> ResT | None:
diff --git a/src/cqrs/requests/fallback.py b/src/cqrs/requests/fallback.py
new file mode 100644
index 0000000..93f4677
--- /dev/null
+++ b/src/cqrs/requests/fallback.py
@@ -0,0 +1,98 @@
+"""Fallback wrapper for request handlers with optional circuit breaker."""
+
+import dataclasses
+import typing
+
+from cqrs.circuit_breaker import ICircuitBreaker
+from cqrs.generic_utils import get_generic_args_for_origin
+from cqrs.requests.request_handler import RequestHandler, StreamingRequestHandler
+
+RequestHandlerT = type[RequestHandler] | type[StreamingRequestHandler]
+
+_REQUEST_HANDLER_ORIGINS: tuple[type, ...] = (RequestHandler, StreamingRequestHandler)
+
+
+def _type_name(t: type) -> str:
+    return getattr(t, "__name__", str(t))
+
+
+@dataclasses.dataclass(frozen=True)
+class RequestHandlerFallback:
+    """
+    Fallback wrapper for request handlers.
+
+    When the primary handler fails (or circuit breaker is open), the fallback
+    handler is invoked. Use a separate circuit breaker instance per domain
+    (e.g. one for requests) that uses the same adapter class.
+
+    Attributes:
+        primary: The primary request handler class.
+        fallback: The fallback handler class to execute if primary fails.
+        failure_exceptions: Exception types that trigger fallback; if empty, any exception.
+        circuit_breaker: Optional circuit breaker instance (e.g. AioBreakerAdapter).
+
+    Example::
+        request_cb = AioBreakerAdapter(fail_max=5, timeout_duration=60)
+        request_map.bind(
+            MyCommand,
+            RequestHandlerFallback(
+                MyCommandHandler,
+                MyCommandHandlerFallback,
+                failure_exceptions=(ConnectionError, TimeoutError),
+                circuit_breaker=request_cb,
+            ),
+        )
+    """
+
+    primary: RequestHandlerT
+    fallback: RequestHandlerT
+    failure_exceptions: tuple[type[Exception], ...] = ()
+    circuit_breaker: ICircuitBreaker | None = None
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.primary, type) or not isinstance(self.fallback, type):
+            raise TypeError(
+                "RequestHandlerFallback primary and fallback must be handler classes",
+            )
+        primary_streaming = issubclass(self.primary, StreamingRequestHandler)
+        fallback_streaming = issubclass(self.fallback, StreamingRequestHandler)
+        if primary_streaming != fallback_streaming:
+            raise TypeError(
+                "RequestHandlerFallback primary and fallback must be the same handler base type: "
+                "both RequestHandler or both StreamingRequestHandler",
+            )
+        # Validate that primary and fallback handle the same request and response types
+        primary_args = get_generic_args_for_origin(
+            self.primary,
+            _REQUEST_HANDLER_ORIGINS,
+            min_args=2,
+        )
+        fallback_args = get_generic_args_for_origin(
+            self.fallback,
+            _REQUEST_HANDLER_ORIGINS,
+            min_args=2,
+        )
+        if primary_args is not None and fallback_args is not None:
+            # Reject TypeVar (unparameterized) so we only allow concrete types
+            if any(isinstance(a, typing.TypeVar) for a in primary_args + fallback_args):
+                raise TypeError(
+                    "RequestHandlerFallback primary and fallback must be parameterized with concrete types "
+                    "(e.g. RequestHandler[MyCommand, MyResult] or StreamingRequestHandler[MyCommand, MyResult])",
+                )
+            if primary_args[0] != fallback_args[0]:
+                raise TypeError(
+                    "RequestHandlerFallback primary and fallback must handle the same request type: "
+                    f"primary {self.primary.__name__} handles {_type_name(primary_args[0])}, "
+                    f"fallback {self.fallback.__name__} handles {_type_name(fallback_args[0])}",
+                )
+            if primary_args[1] != fallback_args[1]:
+                raise TypeError(
+                    "RequestHandlerFallback primary and fallback must have the same response type: "
+                    f"primary {self.primary.__name__} returns {_type_name(primary_args[1])}, "
+                    f"fallback {self.fallback.__name__} returns {_type_name(fallback_args[1])}",
+                )
+        elif primary_args is None or fallback_args is None:
+            raise TypeError(
+                "RequestHandlerFallback primary and fallback must be parameterized with concrete types "
+                "(e.g. RequestHandler[MyCommand, MyResult] or StreamingRequestHandler[MyCommand, MyResult])",
+            )
diff --git a/src/cqrs/requests/map.py b/src/cqrs/requests/map.py
index 4f6291f..e4eabcd 100644
--- a/src/cqrs/requests/map.py
+++ b/src/cqrs/requests/map.py
@@ -1,7 +1,8 @@
 import typing
 
 from cqrs.requests.cor_request_handler import CORRequestHandler
-from cqrs.requests.request import Request
+from cqrs.requests.fallback import RequestHandlerFallback
+from cqrs.requests.request import IRequest
 from cqrs.requests.request_handler import (
     RequestHandler,
     StreamingRequestHandler,
@@ -9,12 +10,13 @@
 from cqrs.saga.models import SagaContext
 from cqrs.saga.saga import Saga
 
-_KT = typing.TypeVar("_KT", bound=typing.Type[Request])
+_KT = typing.TypeVar("_KT", bound=typing.Type[IRequest])
 
 # Type alias for handler types that can be bound to requests
 HandlerType = (
     typing.Type[RequestHandler | StreamingRequestHandler]
     | typing.List[typing.Type[CORRequestHandler]]
+    | RequestHandlerFallback
 )
 
 
diff --git a/src/cqrs/requests/mermaid.py b/src/cqrs/requests/mermaid.py
index 0a58498..eb87a90 100644
--- a/src/cqrs/requests/mermaid.py
+++ b/src/cqrs/requests/mermaid.py
@@ -60,9 +60,7 @@ def sequence(self) -> str:
             alias = f"H{idx}"
             handler_aliases[handler_name] = alias
             # Truncate long handler names for better diagram readability
-            display_name = (
-                handler_name if len(handler_name) <= 30 else handler_name[:27] + "..."
-            )
+            display_name = handler_name if len(handler_name) <= 30 else handler_name[:27] + "..."
             participants.append(f"{alias} as {display_name}")
 
         lines = ["sequenceDiagram"]
@@ -214,9 +212,7 @@ def class_diagram(self) -> str:
                 fields = request_type.__dataclass_fields__
                 for field_name, field_info in fields.items():
                     field_type = (
-                        field_info.type.__name__
-                        if hasattr(field_info.type, "__name__")
-                        else str(field_info.type)
+                        field_info.type.__name__ if hasattr(field_info.type, "__name__") else str(field_info.type)
                     )
                     lines.append(f"        +{field_name}: {field_type}")
             elif hasattr(request_type, "model_fields"):  # Pydantic v2
@@ -232,9 +228,7 @@ def class_diagram(self) -> str:
                 fields = request_type.__fields__
                 for field_name, field_info in fields.items():
                     field_type = (
-                        field_info.type_.__name__
-                        if hasattr(field_info.type_, "__name__")
-                        else str(field_info.type_)
+                        field_info.type_.__name__ if hasattr(field_info.type_, "__name__") else str(field_info.type_)
                     )
                     lines.append(f"        +{field_name}: {field_type}")
             lines.append("    }")
@@ -244,14 +238,12 @@ def class_diagram(self) -> str:
         for response_type in sorted(response_types, key=lambda x: x.__name__):
             class_name = response_type.__name__
             lines.append(f"    class {class_name} {{")
-            # Try to get fields if it's a Pydantic model or dataclass
+            # Try to get fields from dataclass or model
             if hasattr(response_type, "__dataclass_fields__"):
                 fields = response_type.__dataclass_fields__
                 for field_name, field_info in fields.items():
                     field_type = (
-                        field_info.type.__name__
-                        if hasattr(field_info.type, "__name__")
-                        else str(field_info.type)
+                        field_info.type.__name__ if hasattr(field_info.type, "__name__") else str(field_info.type)
                     )
                     lines.append(f"        +{field_name}: {field_type}")
             elif hasattr(response_type, "model_fields"):  # Pydantic v2
@@ -267,9 +259,7 @@ def class_diagram(self) -> str:
                 fields = response_type.__fields__
                 for field_name, field_info in fields.items():
                     field_type = (
-                        field_info.type_.__name__
-                        if hasattr(field_info.type_, "__name__")
-                        else str(field_info.type_)
+                        field_info.type_.__name__ if hasattr(field_info.type_, "__name__") else str(field_info.type_)
                     )
                     lines.append(f"        +{field_name}: {field_type}")
             lines.append("    }")
diff --git a/src/cqrs/requests/request.py b/src/cqrs/requests/request.py
index efee98b..2a6d70f 100644
--- a/src/cqrs/requests/request.py
+++ b/src/cqrs/requests/request.py
@@ -1,13 +1,152 @@
+import abc
+import dataclasses
+import sys
+import typing
+
 import pydantic
 
+from cqrs.response import IResponse
+
+if sys.version_info >= (3, 11):
+    from typing import Self  # novm
+else:
+    from typing_extensions import Self
+
+
+class IRequest(abc.ABC):
+    """
+    Interface for request-type objects.
+
+    This abstract base class defines the contract that all request implementations
+    must follow. Requests are input objects passed to request handlers and are used
+    for defining queries or commands in the CQRS pattern.
+
+    All request implementations must provide:
+    - `to_dict()`: Convert the request instance to a dictionary representation
+    - `from_dict()`: Create a request instance from a dictionary
+    """
+
+    @abc.abstractmethod
+    def to_dict(self) -> dict:
+        """
+        Convert the request instance to a dictionary representation.
+
+        Returns:
+            A dictionary containing all fields of the request instance.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    @abc.abstractmethod
+    def from_dict(cls, **kwargs) -> Self:
+        """
+        Create a request instance from keyword arguments.
+
+        Args:
+            **kwargs: Keyword arguments matching the request fields.
+
+        Returns:
+            A new instance of the request class.
+        """
+        raise NotImplementedError
+
+
+# Type variables for request/response (defined here to avoid circular import with
+# cqrs.types <-> cqrs.requests.request_handler). Re-exported from cqrs.types for compatibility.
+ReqT = typing.TypeVar("ReqT", bound=IRequest, contravariant=True)
+ResT = typing.TypeVar("ResT", bound=IResponse | None, covariant=True)
+
+
+@dataclasses.dataclass
+class DCRequest(IRequest):
+    """
+    Dataclass-based implementation of the request interface.
+
+    This class provides a request implementation using Python's dataclasses.
+    It's useful when you want to avoid pydantic dependency or prefer dataclasses
+    for request definitions.
+
+    Example::
 
-class Request(pydantic.BaseModel):
+        @dataclasses.dataclass
+        class GetUserQuery(DCRequest):
+            user_id: str
+
+        query = GetUserQuery(user_id="123")
+        data = query.to_dict()  # {"user_id": "123"}
+        restored = GetUserQuery.from_dict(**data)
+    """
+
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        """
+        Create a request instance from keyword arguments.
+
+        Args:
+            **kwargs: Keyword arguments matching the dataclass fields.
+
+        Returns:
+            A new instance of the request class.
+        """
+        return cls(**kwargs)
+
+    def to_dict(self) -> dict:
+        """
+        Convert the request instance to a dictionary representation.
+
+        Returns:
+            A dictionary containing all fields of the dataclass instance.
+        """
+        return dataclasses.asdict(self)
+
+
+class PydanticRequest(pydantic.BaseModel, IRequest):
     """
-    Base class for request-type objects.
+    Pydantic-based implementation of the request interface.
+
+    This class provides a request implementation using Pydantic models.
+    It offers data validation, serialization, and other Pydantic features.
+    This is the default request implementation used by the library.
 
     The request is an input of the request handler.
     Often Request is used for defining queries or commands.
+
+    Example::
+
+        class CreateUserCommand(PydanticRequest):
+            username: str
+            email: str
+
+        command = CreateUserCommand(username="john", email="john@example.com")
+        data = command.to_dict()  # {"username": "john", "email": "john@example.com"}
+        restored = CreateUserCommand.from_dict(**data)
     """
 
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        """
+        Create a request instance from keyword arguments.
+
+        Validates and converts types, ensuring required fields are present.
+
+        Args:
+            **kwargs: Keyword arguments matching the request fields.
+
+        Returns:
+            A new instance of the request class.
+        """
+        return cls.model_validate(kwargs)
+
+    def to_dict(self) -> dict:
+        """
+        Convert the request instance to a dictionary representation.
+
+        Returns:
+            A dictionary containing all fields of the request instance.
+        """
+        return self.model_dump(mode="python")
+
+
+Request = PydanticRequest
 
-__all__ = ("Request",)
+__all__ = ("Request", "IRequest", "DCRequest", "PydanticRequest", "ReqT", "ResT")
diff --git a/src/cqrs/requests/request_handler.py b/src/cqrs/requests/request_handler.py
index 0e2d761..751f47c 100644
--- a/src/cqrs/requests/request_handler.py
+++ b/src/cqrs/requests/request_handler.py
@@ -1,8 +1,8 @@
 import abc
 import typing
 
-from cqrs.events.event import Event
-from cqrs.types import ReqT, ResT
+from cqrs.events.event import IEvent
+from cqrs.requests.request import ReqT, ResT
 
 
 class RequestHandler(abc.ABC, typing.Generic[ReqT, ResT]):
@@ -16,7 +16,7 @@ class RequestHandler(abc.ABC, typing.Generic[ReqT, ResT]):
       class JoinMeetingCommandHandler(RequestHandler[JoinMeetingCommand, None])
           def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
               self._meetings_api = meetings_api
-              self.events: list[Event] = []
+              self.events: list[IEvent] = []
 
           async def handle(self, request: JoinMeetingCommand) -> None:
               await self._meetings_api.join_user(request.user_id, request.meeting_id)
@@ -26,7 +26,7 @@ async def handle(self, request: JoinMeetingCommand) -> None:
       class ReadMeetingQueryHandler(RequestHandler[ReadMeetingQuery, ReadMeetingQueryResult])
           def __init__(self, meetings_api: MeetingAPIProtocol) -> None:
               self._meetings_api = meetings_api
-              self.events: list[Event] = []
+              self.events: list[IEvent] = []
 
           async def handle(self, request: ReadMeetingQuery) -> ReadMeetingQueryResult:
               link = await self._meetings_api.get_link(request.meeting_id)
@@ -35,9 +35,14 @@ async def handle(self, request: ReadMeetingQuery) -> ReadMeetingQueryResult:
     """
 
     @property
-    @abc.abstractmethod
-    def events(self) -> typing.List[Event]:
-        raise NotImplementedError
+    def events(self) -> typing.Sequence[IEvent]:
+        """
+        Events produced by this handler after :meth:`handle` was called.
+
+        Override in subclasses to return follow-up events. By default returns
+        an empty sequence.
+        """
+        return ()
 
     @abc.abstractmethod
     async def handle(self, request: ReqT) -> ResT:
@@ -74,12 +79,23 @@ async def handle(self, request: ProcessItemsCommand) -> typing.AsyncIterator[Pro
     """
 
     @property
-    @abc.abstractmethod
-    def events(self) -> typing.List[Event]:
-        raise NotImplementedError
+    def events(self) -> typing.Sequence[IEvent]:
+        """
+        Events produced by this handler after each yield from :meth:`handle`.
+
+        Override in subclasses to return follow-up events. By default returns
+        an empty sequence.
+        """
+        return ()
 
     @abc.abstractmethod
-    async def handle(self, request: ReqT) -> typing.AsyncIterator[ResT]:
+    def handle(self, request: ReqT) -> typing.AsyncIterator[ResT]:
+        """
+        Handle the request by yielding results as an async generator.
+
+        Subclasses must implement this as an async generator (async def with
+        yield) so that callers receive an AsyncIterator when calling handle().
+        """
         raise NotImplementedError
 
     @abc.abstractmethod
diff --git a/src/cqrs/response.py b/src/cqrs/response.py
index 31871dc..8f9a6f3 100644
--- a/src/cqrs/response.py
+++ b/src/cqrs/response.py
@@ -1,11 +1,146 @@
+import abc
+import dataclasses
+import sys
+
 import pydantic
 
+if sys.version_info >= (3, 11):
+    from typing import Self  # novm
+else:
+    from typing_extensions import Self
+
+
+class IResponse(abc.ABC):
+    """
+    Interface for response-type objects.
+
+    This abstract base class defines the contract that all response implementations
+    must follow. Responses are result objects returned by request handlers and are
+    typically used for defining the result of queries in the CQRS pattern.
+
+    All response implementations must provide:
+    - `to_dict()`: Convert the response instance to a dictionary representation
+    - `from_dict()`: Create a response instance from a dictionary
+    """
+
+    @abc.abstractmethod
+    def to_dict(self) -> dict:
+        """
+        Convert the response instance to a dictionary representation.
+
+        Returns:
+            A dictionary containing all fields of the response instance.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    @abc.abstractmethod
+    def from_dict(cls, **kwargs) -> Self:
+        """
+        Create a response instance from keyword arguments.
+
+        Args:
+            **kwargs: Keyword arguments matching the response fields.
+
+        Returns:
+            A new instance of the response class.
+        """
+        raise NotImplementedError
+
+
+@dataclasses.dataclass
+class DCResponse(IResponse):
+    """
+    Dataclass-based implementation of the response interface.
+
+    This class provides a response implementation using Python's dataclasses.
+    It's useful when you want to avoid pydantic dependency or prefer dataclasses
+    for response definitions.
+
+    Example::
+
+        @dataclasses.dataclass
+        class UserResponse(DCResponse):
+            user_id: str
+            username: str
+            email: str
+
+        response = UserResponse(user_id="123", username="john", email="john@example.com")
+        data = response.to_dict()  # {"user_id": "123", "username": "john", "email": "john@example.com"}
+        restored = UserResponse.from_dict(**data)
+    """
+
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        """
+        Create a response instance from keyword arguments.
+
+        Args:
+            **kwargs: Keyword arguments matching the dataclass fields.
+
+        Returns:
+            A new instance of the response class.
+        """
+        return cls(**kwargs)
+
+    def to_dict(self) -> dict:
+        """
+        Convert the response instance to a dictionary representation.
 
-class Response(pydantic.BaseModel):
+        Returns:
+            A dictionary containing all fields of the dataclass instance.
+        """
+        return dataclasses.asdict(self)
+
+
+class PydanticResponse(pydantic.BaseModel, IResponse):
     """
-    Base class for response type objects.
+    Pydantic-based implementation of the response interface.
 
-    The response is a result of the request handling, which hold by RequestHandler.
+    This class provides a response implementation using Pydantic models.
+    It offers data validation, serialization, and other Pydantic features.
+    This is the default response implementation used by the library.
 
+    The response is a result of the request handling, which is held by RequestHandler.
     Often the response is used for defining the result of the query.
+
+    Example::
+
+        class UserResponse(PydanticResponse):
+            user_id: str
+            username: str
+            email: str
+
+        response = UserResponse(user_id="123", username="john", email="john@example.com")
+        data = response.to_dict()  # {"user_id": "123", "username": "john", "email": "john@example.com"}
+        restored = UserResponse.from_dict(**data)
     """
+
+    @classmethod
+    def from_dict(cls, **kwargs) -> Self:
+        """
+        Create a response instance from keyword arguments.
+
+        Validates and converts types, ensuring required fields are present.
+
+        Args:
+            **kwargs: Keyword arguments matching the response fields.
+
+        Returns:
+            A new instance of the response class.
+        """
+        return cls.model_validate(kwargs)
+
+    def to_dict(self) -> dict:
+        """
+        Convert the response instance to a dictionary representation.
+
+        Returns:
+            A dictionary containing all fields of the response instance.
+        """
+        return self.model_dump(mode="python")
+
+
+Response = PydanticResponse
+
+__all__ = ("Response", "IResponse", "DCResponse", "PydanticResponse")
diff --git a/src/cqrs/saga/bootstrap.py b/src/cqrs/saga/bootstrap.py
index d9ea008..f772da7 100644
--- a/src/cqrs/saga/bootstrap.py
+++ b/src/cqrs/saga/bootstrap.py
@@ -185,7 +185,7 @@ def events_mapper(mapper: cqrs.EventMap) -> None:
             saga_storage=MemorySagaStorage(),
         )
 
-        # Execute saga
+        # Execute saga (stream() returns AsyncIterator, consumed with async for)
         async for result in mediator.stream(order_context):
             print(f"Step: {result.step_result.step_type.__name__}")
 
@@ -248,11 +248,13 @@ def events_mapper(mapper: cqrs.EventMap) -> None:
     middlewares_list: typing.List[mediator_middlewares.Middleware] = list(
         middlewares or [],
     )
+    if not any(isinstance(m, logging_middleware.LoggingMiddleware) for m in middlewares_list):
+        middlewares_list.append(logging_middleware.LoggingMiddleware())
 
     return setup_saga_mediator(
         event_emitter,
         container,
-        middlewares=middlewares_list + [logging_middleware.LoggingMiddleware()],
+        middlewares=middlewares_list,
         sagas_mapper=sagas_mapper,
         event_map=event_emitter._event_map,
         max_concurrent_event_handlers=max_concurrent_event_handlers,
diff --git a/src/cqrs/saga/circuit_breaker.py b/src/cqrs/saga/circuit_breaker.py
new file mode 100644
index 0000000..ee685d7
--- /dev/null
+++ b/src/cqrs/saga/circuit_breaker.py
@@ -0,0 +1,57 @@
+"""Circuit breaker protocol for Saga steps."""
+
+import typing
+
+from cqrs.saga.step import SagaStepHandler
+
+
+class ISagaStepCircuitBreaker(typing.Protocol):
+    """
+    Interface for circuit breaker implementations.
+
+    Circuit breakers protect saga steps from cascading failures by opening
+    the circuit when a service is unhealthy, allowing the system to fail fast
+    and switch to fallback logic.
+    """
+
+    async def call(
+        self,
+        step_type: type[SagaStepHandler],
+        func: typing.Callable[..., typing.Awaitable[typing.Any]],
+        *args: typing.Any,
+        **kwargs: typing.Any,
+    ) -> typing.Any:
+        """
+        Execute the function with circuit breaker protection.
+
+        Args:
+            step_type: The step handler class type. MUST be used to determine
+                      the namespace/identity of the breaker.
+            func: The async function to execute.
+            *args: Positional arguments to pass to func.
+            **kwargs: Keyword arguments to pass to func.
+
+        Returns:
+            The result of func execution.
+
+        Raises:
+            CircuitBreakerError: If the circuit breaker is open.
+            Exception: Any exception raised by func (if circuit is closed).
+        """
+        ...
+
+    def is_circuit_breaker_error(self, exc: Exception) -> bool:
+        """
+        Check if the given exception is a circuit breaker error.
+
+        This method allows implementations to determine if an exception
+        represents a circuit breaker being open, without exposing concrete
+        implementation details.
+
+        Args:
+            exc: The exception to check.
+
+        Returns:
+            True if the exception is a circuit breaker error, False otherwise.
+        """
+        ...
diff --git a/src/cqrs/saga/compensation.py b/src/cqrs/saga/compensation.py
new file mode 100644
index 0000000..5ab3eb5
--- /dev/null
+++ b/src/cqrs/saga/compensation.py
@@ -0,0 +1,187 @@
+"""Compensation components for Saga transactions."""
+
+import asyncio
+import logging
+import typing
+
+from cqrs.saga.models import ContextT
+from cqrs.saga.step import SagaStepHandler
+from cqrs.saga.storage.enums import SagaStepStatus, SagaStatus
+from cqrs.saga.storage.protocol import ISagaStorage, SagaStorageRun
+
+logger = logging.getLogger("cqrs.saga")
+
+
+class SagaCompensator(typing.Generic[ContextT]):
+    """Handles compensation of saga steps with retry mechanism."""
+
+    def __init__(
+        self,
+        saga_id: typing.Any,
+        context: ContextT,
+        storage: ISagaStorage | SagaStorageRun,
+        retry_count: int = 3,
+        retry_delay: float = 1.0,
+        retry_backoff: float = 2.0,
+        on_after_compensate_step: typing.Callable[[], typing.Awaitable[None]] | None = None,
+    ) -> None:
+        """
+        Create a SagaCompensator configured to perform compensation of completed saga steps with retry and optional post-step callback.
+
+        Parameters:
+            saga_id: Identifier of the saga.
+            context: Saga execution context passed to step compensation handlers.
+            storage: Storage or run object implementing saga persistence operations.
+            retry_count: Maximum number of attempts per step before giving up.
+            retry_delay: Initial delay in seconds before the first retry.
+            retry_backoff: Multiplier applied to the delay for each successive retry (exponential backoff).
+            on_after_compensate_step: Optional async callback invoked after each step is successfully compensated.
+        """
+        self._saga_id = saga_id
+        self._context = context
+        self._storage = storage
+        self._retry_count = retry_count
+        self._retry_delay = retry_delay
+        self._retry_backoff = retry_backoff
+        self._on_after_compensate_step = on_after_compensate_step
+
+    async def compensate_steps(
+        self,
+        completed_steps: list[SagaStepHandler[ContextT, typing.Any]],
+    ) -> None:
+        """
+        Compensates completed saga steps in reverse order, applying retry logic and recording step statuses.
+
+        Compensates each handler from last to first, skipping steps already recorded as compensated in the saga history. Updates the saga status to COMPENSATING at the start and logs per-step statuses (STARTED, COMPLETED, FAILED) in storage. After a step completes, the optional on_after_compensate_step callback (if provided) is awaited. If any step fails after all retry attempts, the saga is marked as FAILED. If no completed steps are provided, no compensation is attempted and the saga is marked as FAILED.
+
+        Parameters:
+            completed_steps (list[SagaStepHandler[ContextT, typing.Any]]): Handlers corresponding to steps that completed during the saga; these will be compensated in reverse order.
+
+        Returns:
+            None
+        """
+        await self._storage.update_status(self._saga_id, SagaStatus.COMPENSATING)
+
+        if not completed_steps:
+            logger.info(
+                f"Saga {self._saga_id}: completed_steps is empty, "
+                "skipping compensation (no step.compensate() will be called).",
+            )
+            await self._storage.update_status(self._saga_id, SagaStatus.FAILED)
+            return
+
+        # Load history to skip already compensated steps
+        history = await self._storage.get_step_history(self._saga_id)
+        compensated_steps = {
+            e.step_name for e in history if e.status == SagaStepStatus.COMPLETED and e.action == "compensate"
+        }
+
+        compensation_errors: list[tuple[SagaStepHandler[ContextT, typing.Any], Exception]] = []
+
+        for step in reversed(completed_steps):
+            step_name = step.__class__.__name__
+
+            if step_name in compensated_steps:
+                logger.debug(f"Skipping already compensated step: {step_name}")
+                continue
+
+            try:
+                await self._storage.log_step(
+                    self._saga_id,
+                    step_name,
+                    "compensate",
+                    SagaStepStatus.STARTED,
+                )
+
+                await self._compensate_step_with_retry(step)
+
+                await self._storage.update_context(
+                    self._saga_id,
+                    self._context.to_dict(),
+                )
+                await self._storage.log_step(
+                    self._saga_id,
+                    step_name,
+                    "compensate",
+                    SagaStepStatus.COMPLETED,
+                )
+            except Exception as compensation_error:
+                await self._storage.log_step(
+                    self._saga_id,
+                    step_name,
+                    "compensate",
+                    SagaStepStatus.FAILED,
+                    str(compensation_error),
+                )
+                # Store both step and error for better error reporting
+                compensation_errors.append((step, compensation_error))
+                continue
+
+            # Callback only after successful step compensation; failures are not treated as step failure
+            if self._on_after_compensate_step is not None:
+                try:
+                    await self._on_after_compensate_step()
+                except Exception as callback_error:
+                    logger.error(
+                        "on_after_compensate_step failed (e.g. run.commit): %s",
+                        callback_error,
+                        exc_info=callback_error,
+                    )
+                    raise
+
+        # If compensation failed after all retries
+        if compensation_errors:
+            for step, comp_error in compensation_errors:
+                step_name = step.__class__.__name__
+                logger.error(
+                    f"Compensation failed for step '{step_name}' after {self._retry_count} attempts. "
+                    f"Error: {type(comp_error).__name__}: {comp_error}",
+                    exc_info=comp_error,
+                )
+            # Mark as failed eventually
+            await self._storage.update_status(self._saga_id, SagaStatus.FAILED)
+        else:
+            # All compensations completed or were skipped — mark saga as FAILED because the original forward transaction failed
+            await self._storage.update_status(self._saga_id, SagaStatus.FAILED)
+
+    async def _compensate_step_with_retry(
+        self,
+        step: SagaStepHandler[ContextT, typing.Any],
+    ) -> None:
+        """
+        Compensate a single step with retry mechanism and exponential backoff.
+
+        Args:
+            step: The step handler to compensate
+
+        Raises:
+            Exception: If compensation fails after all retry attempts
+        """
+        step_name = step.__class__.__name__
+
+        last_exception: Exception | None = None
+        for attempt in range(1, self._retry_count + 1):
+            try:
+                await step.compensate(self._context)
+                logger.debug(
+                    f"Successfully compensated step '{step_name}' on attempt {attempt}",
+                )
+                return
+            except Exception as e:
+                last_exception = e
+                if attempt < self._retry_count:
+                    # Calculate exponential backoff delay
+                    delay = self._retry_delay * (self._retry_backoff ** (attempt - 1))
+                    logger.warning(
+                        f"Compensation attempt {attempt}/{self._retry_count} failed for step '{step_name}': {e}. "
+                        f"Retrying in {delay:.2f}s...",
+                    )
+                    await asyncio.sleep(delay)
+                else:
+                    logger.error(
+                        f"Compensation failed for step '{step_name}' after {self._retry_count} attempts: {e}",
+                    )
+
+        # If we get here, all retries failed
+        if last_exception:
+            raise last_exception
diff --git a/src/cqrs/saga/execution.py b/src/cqrs/saga/execution.py
new file mode 100644
index 0000000..1c0b611
--- /dev/null
+++ b/src/cqrs/saga/execution.py
@@ -0,0 +1,368 @@
+"""Execution components for Saga transactions."""
+
+import copy
+import dataclasses
+import logging
+import typing
+
+from cqrs.container.protocol import Container
+from cqrs.saga.fallback import Fallback
+from cqrs.saga.models import ContextT, SagaContext
+from cqrs.saga.step import SagaStepHandler, SagaStepResult
+from cqrs.saga.storage.enums import SagaStepStatus
+from cqrs.saga.storage.protocol import ISagaStorage, SagaStorageRun
+
+logger = logging.getLogger("cqrs.saga")
+
+
+class SagaStateManager:
+    """Manages saga state in storage."""
+
+    def __init__(
+        self,
+        saga_id: typing.Any,
+        storage: ISagaStorage | SagaStorageRun,
+    ) -> None:
+        """
+        Create a SagaStateManager bound to a specific saga identifier and storage backend.
+
+        Parameters:
+            saga_id: Identifier for the saga instance.
+            storage: Storage backend implementing ISagaStorage or SagaStorageRun used to persist saga state and history.
+        """
+        self._saga_id = saga_id
+        self._storage = storage
+
+    async def create_saga(
+        self,
+        saga_name: str,
+        context: SagaContext,
+    ) -> None:
+        """Create a new saga in storage."""
+        await self._storage.create_saga(
+            self._saga_id,
+            saga_name,
+            context.to_dict(),
+        )
+
+    async def update_status(self, status: typing.Any) -> None:
+        """Update saga status."""
+        await self._storage.update_status(self._saga_id, status)
+
+    async def update_context(self, context: SagaContext) -> None:
+        """Update saga context."""
+        await self._storage.update_context(
+            self._saga_id,
+            context.to_dict(),
+        )
+
+    async def log_step(
+        self,
+        step_name: str,
+        action: typing.Literal["act", "compensate"],
+        status: SagaStepStatus,
+        error: str | None = None,
+    ) -> None:
+        """Log step execution."""
+        await self._storage.log_step(
+            self._saga_id,
+            step_name,
+            action,
+            status,
+            details=error,
+        )
+
+
+class SagaRecoveryManager:
+    """Manages saga recovery from storage."""
+
+    def __init__(
+        self,
+        saga_id: typing.Any,
+        storage: ISagaStorage | SagaStorageRun,
+        container: Container,
+        saga_steps: list[type[SagaStepHandler] | Fallback],
+    ) -> None:
+        """
+        Construct a SagaRecoveryManager that holds the identifiers, storage, DI container, and configured saga steps required to reconstruct a saga's execution state.
+
+        Parameters:
+            saga_id: Identifier for the saga instance (e.g., UUID or other unique value).
+            storage: Persistence backend implementing saga history operations (ISagaStorage or SagaStorageRun).
+            container: Dependency injection container used to resolve step handler instances.
+            saga_steps: Ordered list of saga step types or Fallback wrappers that define the saga's execution sequence.
+        """
+        self._saga_id = saga_id
+        self._storage = storage
+        self._container = container
+        self._saga_steps = saga_steps
+
+    async def load_completed_step_names(self) -> set[str]:
+        """
+        Return the names of saga steps that completed their primary ("act") action.
+
+        Returns:
+            set[str]: Step names recorded with status `SagaStepStatus.COMPLETED` and action `"act"`.
+        """
+        history = await self._storage.get_step_history(self._saga_id)
+        return {e.step_name for e in history if e.status == SagaStepStatus.COMPLETED and e.action == "act"}
+
+    async def reconstruct_completed_steps(
+        self,
+        completed_step_names: set[str],
+    ) -> list[SagaStepHandler[SagaContext, typing.Any]]:
+        """
+        Reconstructs and returns the resolved step handler instances corresponding to the completed steps, preserving saga execution order.
+
+        Parameters:
+            completed_step_names (set[str]): Names of steps that completed the "act" action.
+
+        Returns:
+            list[SagaStepHandler[SagaContext, typing.Any]]: Resolved step handler instances in execution order. For Fallback wrappers, the primary handler is chosen if its name appears in completed_step_names; otherwise the fallback handler is chosen when present.
+        """
+        completed_steps: list[SagaStepHandler[SagaContext, typing.Any]] = []
+
+        for step_item in self._saga_steps:
+            # Handle Fallback wrapper
+            if isinstance(step_item, Fallback):
+                # Check both primary and fallback step names
+                primary_name = step_item.step.__name__
+                fallback_name = step_item.fallback.__name__
+                if primary_name in completed_step_names:
+                    step = await self._container.resolve(step_item.step)
+                    completed_steps.append(step)
+                elif fallback_name in completed_step_names:
+                    step = await self._container.resolve(step_item.fallback)
+                    completed_steps.append(step)
+            else:
+                # Regular step
+                step_name = step_item.__name__
+                if step_name in completed_step_names:
+                    step = await self._container.resolve(step_item)
+                    completed_steps.append(step)
+
+        return completed_steps
+
+
+class SagaStepExecutor(typing.Generic[ContextT]):
+    """Executes regular saga steps."""
+
+    def __init__(
+        self,
+        context: ContextT,
+        container: Container,
+        state_manager: SagaStateManager,
+    ) -> None:
+        """
+        Initialize step executor.
+
+        Args:
+            context: Saga context
+            container: DI container for resolving step handlers
+            state_manager: State manager for logging and updates
+        """
+        self._context = context
+        self._container = container
+        self._state_manager = state_manager
+
+    async def execute_step(
+        self,
+        step_type: type[SagaStepHandler],
+        step_name: str,
+    ) -> SagaStepResult[ContextT, typing.Any]:
+        """
+        Execute a regular saga step.
+
+        Args:
+            step_type: Type of the step handler
+            step_name: Name of the step (for logging)
+
+        Returns:
+            Result of step execution
+        """
+        # Resolve step handler from DI container
+        step = await self._container.resolve(step_type)
+
+        # Log step start
+        await self._state_manager.log_step(
+            step_name,
+            "act",
+            SagaStepStatus.STARTED,
+        )
+
+        # Execute step
+        step_result = await step.act(self._context)
+
+        # Update context and log completion
+        await self._state_manager.update_context(self._context)
+        await self._state_manager.log_step(
+            step_name,
+            "act",
+            SagaStepStatus.COMPLETED,
+        )
+
+        return step_result
+
+
+class FallbackStepExecutor(typing.Generic[ContextT]):
+    """Executes Fallback wrapper steps with context snapshot/restore."""
+
+    def __init__(
+        self,
+        context: ContextT,
+        container: Container,
+        state_manager: SagaStateManager,
+    ) -> None:
+        """
+        Initialize fallback step executor.
+
+        Args:
+            context: Saga context
+            container: DI container for resolving step handlers
+            state_manager: State manager for logging and updates
+        """
+        self._context = context
+        self._container = container
+        self._state_manager = state_manager
+
+    async def execute_fallback_step(
+        self,
+        fallback_wrapper: Fallback,
+        completed_step_names: set[str],
+    ) -> tuple[SagaStepResult[ContextT, typing.Any] | None, SagaStepHandler | None]:
+        """
+        Execute a Fallback step with context snapshot/restore mechanism.
+
+        Args:
+            fallback_wrapper: The Fallback instance containing step and fallback
+            completed_step_names: Set of completed step names for idempotency check
+
+        Returns:
+            Step result if executed, None if skipped (already completed)
+
+        Raises:
+            Exception: If both primary and fallback steps fail
+        """
+        primary_step_name = fallback_wrapper.step.__name__
+        fallback_step_name = fallback_wrapper.fallback.__name__
+
+        # Idempotency: Check if either primary or fallback is already completed
+        if primary_step_name in completed_step_names:
+            logger.debug(
+                f"Skipping already completed Fallback primary step: {primary_step_name}",
+            )
+            return None, None
+
+        if fallback_step_name in completed_step_names:
+            logger.debug(
+                f"Skipping already completed Fallback fallback step: {fallback_step_name}",
+            )
+            return None, None
+
+        # Resolve step handlers
+        primary_step = await self._container.resolve(fallback_wrapper.step)
+        fallback_step = await self._container.resolve(fallback_wrapper.fallback)
+
+        # Create context snapshot before executing primary step
+        context_snapshot = copy.deepcopy(self._context.to_dict())
+
+        # Try to execute primary step
+        try:
+            await self._state_manager.log_step(
+                primary_step_name,
+                "act",
+                SagaStepStatus.STARTED,
+            )
+
+            # Execute primary step with circuit breaker if present
+            if fallback_wrapper.circuit_breaker is not None:
+                step_result = await fallback_wrapper.circuit_breaker.call(
+                    fallback_wrapper.step,
+                    primary_step.act,
+                    self._context,
+                )
+            else:
+                step_result = await primary_step.act(self._context)
+
+            # Primary step succeeded
+            await self._state_manager.update_context(self._context)
+            await self._state_manager.log_step(
+                primary_step_name,
+                "act",
+                SagaStepStatus.COMPLETED,
+            )
+            return step_result, primary_step
+
+        except Exception as primary_error:
+            should_fallback = False
+
+            # 1. Check Circuit Breaker
+            if (
+                fallback_wrapper.circuit_breaker is not None
+                and fallback_wrapper.circuit_breaker.is_circuit_breaker_error(
+                    primary_error,
+                )
+            ):
+                logger.warning(
+                    f"Circuit breaker open for step '{primary_step_name}'. "
+                    f"Switching to fallback '{fallback_step_name}'.",
+                )
+                should_fallback = True
+
+            # 2. Check failure_exceptions if defined
+            elif fallback_wrapper.failure_exceptions:
+                if isinstance(primary_error, fallback_wrapper.failure_exceptions):
+                    should_fallback = True
+
+            # 3. If no specific exceptions defined, catch all
+            else:
+                should_fallback = True
+
+            if should_fallback:
+                # Log warning but DO NOT log FAILED status for primary step
+                logger.warning(
+                    f"Primary step '{primary_step_name}' failed: {primary_error}. "
+                    f"Switching to fallback '{fallback_step_name}'.",
+                )
+
+                # Restore context from snapshot
+                restored_context = self._context.__class__.from_dict(context_snapshot)
+                # Copy all fields from restored context to the existing one
+                for field in dataclasses.fields(self._context):
+                    setattr(
+                        self._context,
+                        field.name,
+                        getattr(restored_context, field.name),
+                    )
+
+                # Execute fallback step
+                try:
+                    await self._state_manager.log_step(
+                        fallback_step_name,
+                        "act",
+                        SagaStepStatus.STARTED,
+                    )
+
+                    step_result = await fallback_step.act(self._context)
+
+                    # Fallback succeeded
+                    await self._state_manager.update_context(self._context)
+                    await self._state_manager.log_step(
+                        fallback_step_name,
+                        "act",
+                        SagaStepStatus.COMPLETED,
+                    )
+                    return step_result, fallback_step
+
+                except Exception as fallback_error:
+                    # Fallback also failed - saga fails
+                    await self._state_manager.log_step(
+                        fallback_step_name,
+                        "act",
+                        SagaStepStatus.FAILED,
+                        str(fallback_error),
+                    )
+                    raise fallback_error
+            else:
+                # Should not fallback, re-raise original error
+                raise primary_error
diff --git a/src/cqrs/saga/fallback.py b/src/cqrs/saga/fallback.py
new file mode 100644
index 0000000..03ab78d
--- /dev/null
+++ b/src/cqrs/saga/fallback.py
@@ -0,0 +1,35 @@
+"""Fallback wrapper for Saga steps to handle failures gracefully."""
+
+import dataclasses
+
+from cqrs.circuit_breaker import ICircuitBreaker
+from cqrs.saga.step import SagaStepHandler
+
+
+@dataclasses.dataclass(frozen=True)
+class Fallback:
+    """
+    Fallback wrapper for Saga steps.
+
+    Allows defining an alternative step (fallback) to be executed when the primary
+    step fails or when a circuit breaker is open.
+
+    Attributes:
+        step: The primary step handler class to execute.
+        fallback: The fallback step handler class to execute if primary fails.
+        failure_exceptions: Tuple of exception types that trigger fallback immediately.
+        circuit_breaker: Optional circuit breaker instance specific to this step.
+
+    Example::
+        Fallback(
+            step=ReserveInventoryStep,
+            fallback=ReserveInventoryFallbackStep,
+            failure_exceptions=(ConnectionError, TimeoutError),
+            circuit_breaker=cb_adapter
+        )
+    """
+
+    step: type[SagaStepHandler]
+    fallback: type[SagaStepHandler]
+    failure_exceptions: tuple[type[Exception], ...] = ()
+    circuit_breaker: ICircuitBreaker | None = None
diff --git a/src/cqrs/saga/mermaid.py b/src/cqrs/saga/mermaid.py
index 11f1509..a2e745a 100644
--- a/src/cqrs/saga/mermaid.py
+++ b/src/cqrs/saga/mermaid.py
@@ -3,6 +3,7 @@
 import inspect
 import typing
 
+from cqrs.saga.fallback import Fallback
 from cqrs.saga.saga import Saga
 from cqrs.saga.step import SagaStepHandler
 
@@ -54,15 +55,39 @@ def sequence(self) -> str:
         # Generate participant aliases for better readability
         participants = ["S as Saga"]
         step_aliases: dict[str, str] = {}
-
-        for idx, step_type in enumerate(steps, start=1):
-            step_name = step_type.__name__
-            # Create short alias (S1, S2, S3, etc.)
-            alias = f"S{idx}"
-            step_aliases[step_name] = alias
-            # Truncate long step names for better diagram readability
-            display_name = step_name if len(step_name) <= 30 else step_name[:27] + "..."
-            participants.append(f"{alias} as {display_name}")
+        fallback_aliases: dict[str, str] = {}
+        step_idx = 1
+
+        # Process steps and extract participants (including fallback steps)
+        for step_item in steps:
+            if isinstance(step_item, Fallback):
+                # Handle Fallback wrapper
+                primary_name = step_item.step.__name__
+                fallback_name = step_item.fallback.__name__
+
+                # Create aliases for primary and fallback
+                primary_alias = f"S{step_idx}"
+                fallback_alias = f"F{step_idx}"
+                step_aliases[primary_name] = primary_alias
+                fallback_aliases[fallback_name] = fallback_alias
+
+                # Truncate long names
+                primary_display = primary_name if len(primary_name) <= 30 else primary_name[:27] + "..."
+                fallback_display = fallback_name if len(fallback_name) <= 30 else fallback_name[:27] + "..."
+
+                participants.append(f"{primary_alias} as {primary_display}")
+                participants.append(
+                    f"{fallback_alias} as {fallback_display} (fallback)",
+                )
+                step_idx += 1
+            else:
+                # Regular step
+                step_name = step_item.__name__
+                alias = f"S{step_idx}"
+                step_aliases[step_name] = alias
+                display_name = step_name if len(step_name) <= 30 else step_name[:27] + "..."
+                participants.append(f"{alias} as {display_name}")
+                step_idx += 1
 
         lines = ["sequenceDiagram"]
         lines.extend(f"    participant {p}" for p in participants)
@@ -70,49 +95,100 @@ def sequence(self) -> str:
 
         # Generate successful execution flow
         lines.append("    Note over S: Successful Execution Flow")
-        for idx, step_type in enumerate(steps):
-            step_name = step_type.__name__
-            alias = step_aliases[step_name]
-            lines.append(f"    S->>{alias}: act()")
-            lines.append(f"    {alias}-->>S: success")
+        for step_item in steps:
+            if isinstance(step_item, Fallback):
+                # Fallback: show primary step succeeding
+                primary_name = step_item.step.__name__
+                primary_alias = step_aliases[primary_name]
+                lines.append(f"    S->>{primary_alias}: act()")
+                lines.append(f"    {primary_alias}-->>S: success")
+            else:
+                # Regular step
+                step_name = step_item.__name__
+                alias = step_aliases[step_name]
+                lines.append(f"    S->>{alias}: act()")
+                lines.append(f"    {alias}-->>S: success")
         lines.append("    Note over S: Saga Completed")
         lines.append("")
 
-        # Generate failure and compensation flow
+        # Generate failure and compensation flow with fallback
         lines.append("    Note over S: Failure & Compensation Flow")
-        # Execute steps until failure
         if len(steps) > 1:
             # Show all steps except the last one succeeding
-            for step_type in steps[:-1]:
-                step_name = step_type.__name__
-                alias = step_aliases[step_name]
-                lines.append(f"    S->>{alias}: act()")
-                lines.append(f"    {alias}-->>S: success")
+            for step_item in steps[:-1]:
+                if isinstance(step_item, Fallback):
+                    primary_name = step_item.step.__name__
+                    primary_alias = step_aliases[primary_name]
+                    lines.append(f"    S->>{primary_alias}: act()")
+                    lines.append(f"    {primary_alias}-->>S: success")
+                else:
+                    step_name = step_item.__name__
+                    alias = step_aliases[step_name]
+                    lines.append(f"    S->>{alias}: act()")
+                    lines.append(f"    {alias}-->>S: success")
 
             # Show last step failing
             last_step = steps[-1]
-            last_alias = step_aliases[last_step.__name__]
-            lines.append(f"    S->>{last_alias}: act()")
-            lines.append(f"    {last_alias}-->>S: error")
+            if isinstance(last_step, Fallback):
+                # Fallback step: show primary failing, then fallback succeeding
+                primary_name = last_step.step.__name__
+                fallback_name = last_step.fallback.__name__
+                primary_alias = step_aliases[primary_name]
+                fallback_alias = fallback_aliases[fallback_name]
+
+                lines.append(f"    S->>{primary_alias}: act()")
+                lines.append(f"    {primary_alias}-->>S: error")
+                lines.append("    Note over S: Fallback triggered")
+                lines.append(f"    S->>{fallback_alias}: act()")
+                lines.append(f"    {fallback_alias}-->>S: success")
+            else:
+                # Regular step failing
+                last_alias = step_aliases[last_step.__name__]
+                lines.append(f"    S->>{last_alias}: act()")
+                lines.append(f"    {last_alias}-->>S: error")
+
             lines.append("")
 
             # Compensate completed steps in reverse order
             lines.append("    Note over S: Compensation (reverse order)")
             # Compensate all steps before the failing one (in reverse order)
-            for step_type in reversed(steps[:-1]):
-                step_name = step_type.__name__
-                alias = step_aliases[step_name]
-                lines.append(f"    S->>{alias}: compensate()")
-                lines.append(f"    {alias}-->>S: success")
+            for step_item in reversed(steps[:-1]):
+                if isinstance(step_item, Fallback):
+                    # For fallback steps, compensate the step that actually executed
+                    # In success case, it's the primary; in failure case, it could be fallback
+                    # For simplicity, show primary compensation
+                    primary_name = step_item.step.__name__
+                    primary_alias = step_aliases[primary_name]
+                    lines.append(f"    S->>{primary_alias}: compensate()")
+                    lines.append(f"    {primary_alias}-->>S: success")
+                else:
+                    step_name = step_item.__name__
+                    alias = step_aliases[step_name]
+                    lines.append(f"    S->>{alias}: compensate()")
+                    lines.append(f"    {alias}-->>S: success")
         else:
             # Single step scenario
             single_step = steps[0]
-            single_alias = step_aliases[single_step.__name__]
-            lines.append(f"    S->>{single_alias}: act()")
-            lines.append(f"    {single_alias}-->>S: error")
-            lines.append(
-                "    Note over S: No compensation needed (step failed before completion)",
-            )
+            if isinstance(single_step, Fallback):
+                # Fallback step: show primary failing, then fallback succeeding
+                primary_name = single_step.step.__name__
+                fallback_name = single_step.fallback.__name__
+                primary_alias = step_aliases[primary_name]
+                fallback_alias = fallback_aliases[fallback_name]
+
+                lines.append(f"    S->>{primary_alias}: act()")
+                lines.append(f"    {primary_alias}-->>S: error")
+                lines.append("    Note over S: Fallback triggered")
+                lines.append(f"    S->>{fallback_alias}: act()")
+                lines.append(f"    {fallback_alias}-->>S: success")
+                lines.append("    Note over S: Saga Completed (via fallback)")
+            else:
+                single_alias = step_aliases[single_step.__name__]
+                lines.append(f"    S->>{single_alias}: act()")
+                lines.append(f"    {single_alias}-->>S: error")
+                lines.append(
+                    "    Note over S: No compensation needed (step failed before completion)",
+                )
 
         lines.append("    Note over S: Saga Failed")
 
@@ -135,9 +211,7 @@ def class_diagram(self) -> str:
         steps = self._saga.steps
 
         if not steps:
-            return (
-                "classDiagram\n    class Saga\n    Note for Saga: No steps configured"
-            )
+            return "classDiagram\n    class Saga\n    Note for Saga: No steps configured"
 
         # Collect all types
         context_types: set[type] = set()
@@ -146,40 +220,108 @@ def class_diagram(self) -> str:
         step_info: list[tuple[str, type | None, type | None, list[type]]] = []
 
         # Extract type information from each step
-        for step_type in steps:
-            step_name = step_type.__name__
-            context_type: type | None = None
-            response_type: type | None = None
-            step_events: list[type] = []
-
-            # Extract generic type parameters from __orig_bases__
-            orig_bases = getattr(step_type, "__orig_bases__", ())
-            for base in orig_bases:
-                origin = typing.get_origin(base)
-                # Check if this base is SagaStepHandler or a subclass
-                if origin is SagaStepHandler:
-                    args = typing.get_args(base)
-                    if len(args) >= 1 and args[0] is not typing.Any:
-                        context_type = args[0]
-                        if inspect.isclass(context_type):
-                            context_types.add(context_type)
-                    if len(args) >= 2 and args[1] is not typing.Any:
-                        response_type = args[1]
-                        if inspect.isclass(response_type):
-                            response_types.add(response_type)
-                    break  # Found the right base, no need to continue
-
-            # If not found in __orig_bases__, try __bases__
-            if context_type is None and response_type is None:
-                for base in step_type.__bases__:
-                    if issubclass(base, SagaStepHandler):
-                        # Try to get type hints from the class itself
-                        if hasattr(step_type, "__annotations__"):
-                            # Check if we can infer from class definition
-                            pass
+        for step_item in steps:
+            if isinstance(step_item, Fallback):
+                # Handle Fallback wrapper - extract info from both primary and fallback steps
+                primary_step = step_item.step
+                fallback_step = step_item.fallback
+
+                # Process primary step
+                primary_name = primary_step.__name__
+                primary_context_type: type | None = None
+                primary_response_type: type | None = None
+                primary_events: list[type] = []
+
+                # Extract generic type parameters from primary step
+                orig_bases = getattr(primary_step, "__orig_bases__", ())
+                for base in orig_bases:
+                    origin = typing.get_origin(base)
+                    if origin is SagaStepHandler:
+                        args = typing.get_args(base)
+                        if len(args) >= 1 and args[0] is not typing.Any:
+                            primary_context_type = args[0]
+                            if inspect.isclass(primary_context_type):
+                                context_types.add(primary_context_type)
+                        if len(args) >= 2 and args[1] is not typing.Any:
+                            primary_response_type = args[1]
+                            if inspect.isclass(primary_response_type):
+                                response_types.add(primary_response_type)
+                        break
+
+                # Process fallback step
+                fallback_name = fallback_step.__name__
+                fallback_context_type: type | None = None
+                fallback_response_type: type | None = None
+                fallback_events: list[type] = []
+
+                # Extract generic type parameters from fallback step
+                orig_bases = getattr(fallback_step, "__orig_bases__", ())
+                for base in orig_bases:
+                    origin = typing.get_origin(base)
+                    if origin is SagaStepHandler:
+                        args = typing.get_args(base)
+                        if len(args) >= 1 and args[0] is not typing.Any:
+                            fallback_context_type = args[0]
+                            if inspect.isclass(fallback_context_type):
+                                context_types.add(fallback_context_type)
+                        if len(args) >= 2 and args[1] is not typing.Any:
+                            fallback_response_type = args[1]
+                            if inspect.isclass(fallback_response_type):
+                                response_types.add(fallback_response_type)
                         break
 
-            step_info.append((step_name, context_type, response_type, step_events))
+                # Add both primary and fallback steps to step_info
+                step_info.append(
+                    (
+                        primary_name,
+                        primary_context_type,
+                        primary_response_type,
+                        primary_events,
+                    ),
+                )
+                step_info.append(
+                    (
+                        fallback_name,
+                        fallback_context_type,
+                        fallback_response_type,
+                        fallback_events,
+                    ),
+                )
+            else:
+                # Regular step
+                step_name = step_item.__name__
+                context_type: type | None = None
+                response_type: type | None = None
+                step_events: list[type] = []
+
+                # Extract generic type parameters from __orig_bases__
+                orig_bases = getattr(step_item, "__orig_bases__", ())
+                for base in orig_bases:
+                    origin = typing.get_origin(base)
+                    # Check if this base is SagaStepHandler or a subclass
+                    if origin is SagaStepHandler:
+                        args = typing.get_args(base)
+                        if len(args) >= 1 and args[0] is not typing.Any:
+                            context_type = args[0]
+                            if inspect.isclass(context_type):
+                                context_types.add(context_type)
+                        if len(args) >= 2 and args[1] is not typing.Any:
+                            response_type = args[1]
+                            if inspect.isclass(response_type):
+                                response_types.add(response_type)
+                        break  # Found the right base, no need to continue
+
+                # If not found in __orig_bases__, try __bases__
+                if context_type is None and response_type is None:
+                    for base in step_item.__bases__:
+                        if issubclass(base, SagaStepHandler):
+                            # Try to get type hints from the class itself
+                            if hasattr(step_item, "__annotations__"):
+                                # Check if we can infer from class definition
+                                pass
+                            break
+
+                step_info.append((step_name, context_type, response_type, step_events))
 
         # Build class diagram
         lines = ["classDiagram"]
@@ -209,9 +351,7 @@ def class_diagram(self) -> str:
                 fields = context_type.__dataclass_fields__
                 for field_name, field_info in fields.items():
                     field_type = (
-                        field_info.type.__name__
-                        if hasattr(field_info.type, "__name__")
-                        else str(field_info.type)
+                        field_info.type.__name__ if hasattr(field_info.type, "__name__") else str(field_info.type)
                     )
                     lines.append(f"        +{field_name}: {field_type}")
             lines.append("    }")
@@ -221,14 +361,12 @@ def class_diagram(self) -> str:
         for response_type in sorted(response_types, key=lambda x: x.__name__):
             class_name = response_type.__name__
             lines.append(f"    class {class_name} {{")
-            # Try to get fields if it's a Pydantic model or dataclass
+            # Try to get fields from dataclass or model
             if hasattr(response_type, "__dataclass_fields__"):
                 fields = response_type.__dataclass_fields__
                 for field_name, field_info in fields.items():
                     field_type = (
-                        field_info.type.__name__
-                        if hasattr(field_info.type, "__name__")
-                        else str(field_info.type)
+                        field_info.type.__name__ if hasattr(field_info.type, "__name__") else str(field_info.type)
                     )
                     lines.append(f"        +{field_name}: {field_type}")
             elif hasattr(response_type, "model_fields"):  # Pydantic v2
@@ -244,9 +382,7 @@ def class_diagram(self) -> str:
                 fields = response_type.__fields__
                 for field_name, field_info in fields.items():
                     field_type = (
-                        field_info.type_.__name__
-                        if hasattr(field_info.type_, "__name__")
-                        else str(field_info.type_)
+                        field_info.type_.__name__ if hasattr(field_info.type_, "__name__") else str(field_info.type_)
                     )
                     lines.append(f"        +{field_name}: {field_type}")
             lines.append("    }")
diff --git a/src/cqrs/saga/models.py b/src/cqrs/saga/models.py
index a41e8f6..01335a9 100644
--- a/src/cqrs/saga/models.py
+++ b/src/cqrs/saga/models.py
@@ -1,5 +1,6 @@
 import dataclasses
 import typing
+from dataclass_wizard import asdict, fromdict
 
 # Type variable for from_dict classmethod return type
 _T = typing.TypeVar("_T", bound="SagaContext")
@@ -29,7 +30,7 @@ def to_dict(self) -> dict[str, typing.Any]:
         Returns:
             Dictionary representation of the context.
         """
-        return dataclasses.asdict(self)
+        return asdict(self)
 
     @classmethod
     def from_dict(cls: type[_T], data: dict[str, typing.Any]) -> _T:
@@ -42,11 +43,11 @@ def from_dict(cls: type[_T], data: dict[str, typing.Any]) -> _T:
         Returns:
             Instance of the context class.
         """
-        # Get field names from dataclass
-        field_names = {f.name for f in dataclasses.fields(cls)}
-        # Filter data to only include known fields
-        filtered_data = {k: v for k, v in data.items() if k in field_names}
-        return cls(**filtered_data)
+        # # Get field names from dataclass
+        # field_names = {f.name for f in dataclasses.fields(cls)}
+        # # Filter data to only include known fields
+        # filtered_data = {k: v for k, v in data.items() if k in field_names}
+        return fromdict(cls, data)
 
     def model_dump(self) -> dict[str, typing.Any]:
         """
diff --git a/src/cqrs/saga/recovery.py b/src/cqrs/saga/recovery.py
index cff3354..558c30c 100644
--- a/src/cqrs/saga/recovery.py
+++ b/src/cqrs/saga/recovery.py
@@ -29,6 +29,11 @@ async def recover_saga(
     Already completed steps will be skipped.
     If the saga was in a compensating state, compensation will resume.
 
+    On recovery failure (exception during resume), the storage's
+    increment_recovery_attempts is called automatically so the saga can be
+    retried or excluded by get_sagas_for_recovery(max_recovery_attempts=...).
+    Callers do not need to call increment_recovery_attempts themselves.
+
     Args:
         saga: The saga orchestrator instance.
         saga_id: The ID of the saga to recover.
@@ -37,7 +42,7 @@ async def recover_saga(
                         (assuming the constructor accepts kwargs).
                         If a function is provided, it will be called with the data dict.
                         Examples:
-                            - MyPydanticModel.model_validate
+                            - MyContextClass.from_dict (if implements from_dict interface)
                             - lambda d: MyDataClass(**d)
                             - MyClass (if __init__ accepts **kwargs)
         container: DI container for resolving step handlers.
@@ -104,16 +109,16 @@ async def recover_saga(
         error_msg = str(e)
         if "recovered in" in error_msg and "state" in error_msg:
             logger.warning(
-                f"Saga {saga_id} recovery completed compensation. "
-                "Forward execution was not allowed.",
+                f"Saga {saga_id} recovery completed compensation. " "Forward execution was not allowed.",
             )
             # Re-raise to allow callers to handle this case
             raise
-        # For other RuntimeErrors, log and re-raise
+        # For other RuntimeErrors, recovery failed: increment attempts and re-raise
         logger.error(f"Saga {saga_id} recovery ended with error: {e}")
+        await storage.increment_recovery_attempts(saga_id, new_status=SagaStatus.FAILED)
         raise
     except Exception as e:
         logger.error(f"Saga {saga_id} recovery ended with error: {e}")
-        # The transaction handles exception and runs compensation, so the saga state
-        # should be updated to FAILED (or COMPENSATED) in storage.
+        # Recovery failed: increment attempts so saga can be retried or excluded later
+        await storage.increment_recovery_attempts(saga_id, new_status=SagaStatus.FAILED)
         raise
diff --git a/src/cqrs/saga/saga.py b/src/cqrs/saga/saga.py
index 4adc1dd..db5a3b1 100644
--- a/src/cqrs/saga/saga.py
+++ b/src/cqrs/saga/saga.py
@@ -1,14 +1,26 @@
-import asyncio
+import dataclasses
 import logging
 import types
 import typing
 import uuid
 
 from cqrs.container.protocol import Container
+from cqrs.saga.compensation import SagaCompensator
+from cqrs.saga.execution import (
+    FallbackStepExecutor,
+    SagaRecoveryManager,
+    SagaStateManager,
+    SagaStepExecutor,
+)
+from cqrs.saga.fallback import Fallback
 from cqrs.saga.models import ContextT
 from cqrs.saga.step import SagaStepHandler, SagaStepResult
 from cqrs.saga.storage.enums import SagaStatus, SagaStepStatus
-from cqrs.saga.storage.protocol import ISagaStorage
+from cqrs.saga.storage.protocol import ISagaStorage, SagaStorageRun
+from cqrs.saga.validation import (
+    SagaContextTypeExtractor,
+    SagaStepValidator,
+)
 
 logger = logging.getLogger("cqrs.saga")
 
@@ -74,16 +86,40 @@ def __init__(
         self._completed_steps: list[SagaStepHandler[ContextT, typing.Any]] = []
         self._error: BaseException | None = None
         self._compensated: bool = False
-        self._compensation_retry_count = compensation_retry_count
-        self._compensation_retry_delay = compensation_retry_delay
-        self._compensation_retry_backoff = compensation_retry_backoff
+        self._comp_retry_count = compensation_retry_count
+        self._comp_retry_delay = compensation_retry_delay
+        self._comp_retry_backoff = compensation_retry_backoff
 
         self._saga_id = saga_id or uuid.uuid4()
-        # If saga_id was passed, we assume it's an existing saga if it exists in storage,
-        # but here we treat it as new if not checking storage explicitly.
-        # Ideally, we should check storage in __aiter__.
         self._is_new_saga = saga_id is None
 
+        # Initialize components
+        self._state_manager = SagaStateManager(self._saga_id, storage)
+        self._recovery_manager = SagaRecoveryManager(
+            self._saga_id,
+            storage,
+            container,
+            saga.steps,
+        )
+        self._step_executor: SagaStepExecutor[ContextT] = SagaStepExecutor[ContextT](
+            context,
+            container,
+            self._state_manager,
+        )
+        self._fallback_executor: FallbackStepExecutor[ContextT] = FallbackStepExecutor[ContextT](
+            context,
+            container,
+            self._state_manager,
+        )
+        self._compensator: SagaCompensator[ContextT] = SagaCompensator[ContextT](
+            self._saga_id,
+            context,
+            storage,
+            self._comp_retry_count,
+            self._comp_retry_delay,
+            self._comp_retry_backoff,
+        )
+
     @property
     def saga_id(self) -> uuid.UUID:
         return self._saga_id
@@ -108,9 +144,10 @@ async def __aexit__(
         exc_val: BaseException | None,
         exc_tb: types.TracebackType | None,
     ) -> bool:
-        # If an exception occurred, compensate all completed steps
-        # Only compensate if not already compensated in __aiter__
-        if exc_val is not None and not self._compensated:
+        # If an exception occurred, compensate all completed steps.
+        # Do not compensate on GeneratorExit: consumer stopped iteration intentionally
+        # (e.g. to resume later), which is not a failure.
+        if exc_val is not None and exc_type is not GeneratorExit and not self._compensated:
             self._error = exc_val
             await self._compensate()
         return False  # Don't suppress the exception
@@ -121,300 +158,262 @@ async def __aiter__(
         """
         Execute saga steps sequentially and yield each step result.
 
-        This method implements the "Strict Backward Recovery" strategy for saga execution.
-        Once a saga enters COMPENSATING or FAILED status, it can never proceed forward.
-        This ensures data consistency and prevents "zombie states" where a saga is
-        partially compensated and partially executed.
-
-        Strategy Overview:
-        - Forward Execution (RUNNING/PENDING): Execute steps sequentially, skipping
-          already completed steps for idempotency.
-        - Point of No Return: If saga status is COMPENSATING or FAILED, immediately
-          resume compensation without attempting forward execution. This prevents
-          inconsistent states where partial compensation conflicts with new execution.
-        - Local Retries: Retry logic is handled at the step level (within step.act()).
-          While retrying, saga status remains RUNNING, allowing recovery to continue
-          forward execution if the retry succeeds.
-        - Global Failure: Once all local retries are exhausted and saga transitions
-          to COMPENSATING, the path forward is permanently closed. Only compensation
-          can proceed.
-
-        Yields:
-            SagaStepResult for each successfully executed step.
+        Implements the Strict Backward Recovery strategy: if the saga is in COMPENSATING or FAILED status, forward execution is never resumed. When the underlying storage provides create_run(), execution is performed within a per-saga run with checkpoint commits; otherwise the legacy run-less path is used.
+        Returns:
+                AsyncIterator[SagaStepResult[ContextT, typing.Any]]: An async iterator that yields the result for each executed saga step in order.
+        """
+        try:
+            run_cm = self._storage.create_run()
+        except NotImplementedError:
+            run_cm = None
+
+        if run_cm is not None:
+            async with run_cm as run:
+                async for step_result in self._execute(run):
+                    yield step_result
+        else:
+            async for step_result in self._execute(None):
+                yield step_result
+
+    def _build_run_scoped_components(
+        self,
+        run: SagaStorageRun,
+    ) -> tuple[
+        SagaStateManager,
+        SagaRecoveryManager,
+        SagaStepExecutor[ContextT],
+        FallbackStepExecutor[ContextT],
+        SagaCompensator[ContextT],
+    ]:
+        """Build state manager, recovery manager, executors, and compensator for a storage run (checkpoint commits)."""
+        state_manager = SagaStateManager(self._saga_id, run)
+        recovery_manager = SagaRecoveryManager(
+            self._saga_id,
+            run,
+            self._container,
+            self._saga.steps,
+        )
+        step_executor = SagaStepExecutor(
+            self._context,
+            self._container,
+            state_manager,
+        )
+        fallback_executor = FallbackStepExecutor(
+            self._context,
+            self._container,
+            state_manager,
+        )
+        compensator = SagaCompensator(
+            self._saga_id,
+            self._context,
+            run,
+            self._comp_retry_count,
+            self._comp_retry_delay,
+            self._comp_retry_backoff,
+            on_after_compensate_step=run.commit,
+        )
+        return (
+            state_manager,
+            recovery_manager,
+            step_executor,
+            fallback_executor,
+            compensator,
+        )
+
+    async def _execute(
+        self,
+        run: SagaStorageRun | None,
+    ) -> typing.AsyncIterator[SagaStepResult[ContextT, typing.Any]]:
+        """
+        Execute the saga's configured steps, using the provided storage run for checkpointed operations when available, and perform recovery and compensation as required.
+
+        Parameters:
+            run (SagaStorageRun | None): Optional per-saga storage run. When provided, the run is used for loading saga state, creating run-scoped managers/executors, and committing at checkpoint boundaries. When None, the transaction's internal managers and executors are used.
+
+        Returns:
+            Async iterator that yields SagaStepResult values for each step that completes; each yielded result will include the transaction's saga_id.
 
         Raises:
-            Exception: If any step fails, compensation is triggered and
-                      the exception is re-raised. Also raised when recovering
-                      a saga in COMPENSATING/FAILED status.
+            RuntimeError: If the saga was recovered in COMPENSATING or FAILED state and compensation was completed, forward execution is not allowed.
         """
-        # 1. Initialization / Recovery
-        completed_step_names: set[str] = set()
+        if run is not None:
+            (
+                state_manager,
+                recovery_manager,
+                step_executor,
+                fallback_executor,
+                compensator,
+            ) = self._build_run_scoped_components(run)
+        else:
+            state_manager = self._state_manager
+            recovery_manager = self._recovery_manager
+            step_executor = self._step_executor
+            fallback_executor = self._fallback_executor
+            compensator = self._compensator
 
-        # Determine if we need to create or load
-        # If ID was provided, we check if it exists (basic check logic)
-        # For simplicity, if _is_new_saga is True, we create.
-        # If it was False, we try to load.
+        completed_step_names: set[str] = set()
 
         if self._is_new_saga:
-            await self._storage.create_saga(
-                self._saga_id,
+            await state_manager.create_saga(
                 self._saga.__class__.__name__,
-                self._context.to_dict(),
+                self._context,
             )
-            await self._storage.update_status(self._saga_id, SagaStatus.RUNNING)
+            if run is not None:
+                await run.commit()
+            await state_manager.update_status(SagaStatus.RUNNING)
+            if run is not None:
+                await run.commit()
         else:
-            # Try to recover state
             try:
-                status, _, _ = await self._storage.load_saga_state(
-                    self._saga_id,
-                    read_for_update=True,
-                )
+                if run is not None:
+                    status, _, _ = await run.load_saga_state(
+                        self._saga_id,
+                        read_for_update=True,
+                    )
+                else:
+                    status, _, _ = await self._storage.load_saga_state(
+                        self._saga_id,
+                        read_for_update=True,
+                    )
 
-                # Check for terminal states first
                 if status == SagaStatus.COMPLETED:
                     logger.info(
                         f"Saga {self._saga_id} is already {status}. Skipping execution.",
                     )
                     return
 
-                # POINT OF NO RETURN: Strict Backward Recovery Strategy
-                # If saga is in COMPENSATING or FAILED status, we must complete compensation
-                # and never attempt forward execution. This prevents inconsistent states
-                # where partial compensation conflicts with new execution attempts.
                 if status in (SagaStatus.COMPENSATING, SagaStatus.FAILED):
                     logger.warning(
-                        f"Saga {self._saga_id} is in {status} state. "
-                        "Resuming compensation immediately.",
+                        f"Saga {self._saga_id} is in {status} state. " "Resuming compensation immediately.",
                     )
-
-                    # Restore completed steps from history for compensation
-                    history = await self._storage.get_step_history(self._saga_id)
-                    completed_act_steps = {
-                        e.step_name
-                        for e in history
-                        if e.status == SagaStepStatus.COMPLETED and e.action == "act"
-                    }
-
-                    # Reconstruct completed_steps list in order for proper compensation
-                    for step_type in self._saga.steps:
-                        step_name = step_type.__name__
-                        if step_name in completed_act_steps:
-                            step = await self._container.resolve(step_type)
-                            self._completed_steps.append(step)
-
-                    # Immediately proceed to compensation - no forward execution
-                    await self._compensate()
-
-                    # Raise exception to signal that saga was recovered in failed state
+                    completed_act_steps = await recovery_manager.load_completed_step_names()
+                    reconstructed_steps = await recovery_manager.reconstruct_completed_steps(
+                        completed_act_steps,
+                    )
+                    self._completed_steps = [
+                        typing.cast(SagaStepHandler[ContextT, typing.Any], step) for step in reconstructed_steps
+                    ]
+                    if not self._completed_steps:
+                        logger.warning(
+                            f"Saga {self._saga_id}: no completed steps to compensate "
+                            "(saga failed before any step finished 'act', or step names in "
+                            "storage do not match saga step class names). "
+                            "Marking as FAILED without calling compensate().",
+                        )
+                    await compensator.compensate_steps(self._completed_steps)
+                    if run is not None:
+                        await run.commit()
                     raise RuntimeError(
                         f"Saga {self._saga_id} was recovered in {status} state "
                         "and compensation was completed. Forward execution is not allowed.",
                     )
 
-                # For RUNNING/PENDING status, load history to skip completed steps
-                history = await self._storage.get_step_history(self._saga_id)
-                completed_step_names = {
-                    e.step_name
-                    for e in history
-                    if e.status == SagaStepStatus.COMPLETED and e.action == "act"
-                }
+                completed_step_names = await recovery_manager.load_completed_step_names()
             except ValueError:
-                # If loading fails but ID was provided, maybe treat as new?
-                # Or raise error. Assuming strict consistency for now.
-                # If the user provided an ID that doesn't exist, create it.
-                await self._storage.create_saga(
-                    self._saga_id,
+                if run is not None:
+                    await run.rollback()
+                await state_manager.create_saga(
                     self._saga.__class__.__name__,
-                    self._context.to_dict(),
+                    self._context,
                 )
-                await self._storage.update_status(self._saga_id, SagaStatus.RUNNING)
+                if run is not None:
+                    await run.commit()
+                await state_manager.update_status(SagaStatus.RUNNING)
+                if run is not None:
+                    await run.commit()
 
         step_name = "unknown_step"
         try:
-            for step_type in self._saga.steps:
+            for step_item in self._saga.steps:
+                if isinstance(step_item, Fallback):
+                    (
+                        step_result,
+                        executed_step,
+                    ) = await fallback_executor.execute_fallback_step(
+                        step_item,
+                        completed_step_names,
+                    )
+                    if step_result is not None and executed_step is not None:
+                        self._completed_steps.append(executed_step)
+                        if run is not None:
+                            await run.commit()
+                        yield dataclasses.replace(
+                            step_result,
+                            saga_id=self._saga_id,
+                        )
+                    elif executed_step is None:
+                        primary_name = step_item.step.__name__
+                        fallback_name = step_item.fallback.__name__
+                        if primary_name in completed_step_names:
+                            step = await self._container.resolve(step_item.step)
+                            self._completed_steps.append(step)
+                        elif fallback_name in completed_step_names:
+                            step = await self._container.resolve(step_item.fallback)
+                            self._completed_steps.append(step)
+                    continue
+
+                step_type = step_item
                 step_name = step_type.__name__
 
-                # 2. Skip logic (Idempotency)
                 if step_name in completed_step_names:
-                    # Restore step instance to completed_steps for potential compensation
                     step = await self._container.resolve(step_type)
                     self._completed_steps.append(step)
                     logger.debug(f"Skipping already completed step: {step_name}")
                     continue
 
-                # Resolve step handler from DI container
-                step = await self._container.resolve(step_type)
-
-                # 3. Execution
-                await self._storage.log_step(
-                    self._saga_id,
+                step_result = await step_executor.execute_step(
+                    step_type,
                     step_name,
-                    "act",
-                    SagaStepStatus.STARTED,
                 )
-
-                step_result = await step.act(self._context)
-
+                step = await self._container.resolve(step_type)
                 self._completed_steps.append(step)
-
-                # 4. Commit State
-                await self._storage.update_context(
-                    self._saga_id,
-                    self._context.to_dict(),
-                )
-                await self._storage.log_step(
-                    self._saga_id,
-                    step_name,
-                    "act",
-                    SagaStepStatus.COMPLETED,
+                if run is not None:
+                    await run.commit()
+                yield dataclasses.replace(
+                    step_result,
+                    saga_id=self._saga_id,
                 )
 
-                yield step_result
-
-            await self._storage.update_status(self._saga_id, SagaStatus.COMPLETED)
+            await state_manager.update_context(self._context)
+            await state_manager.update_status(SagaStatus.COMPLETED)
+            if run is not None:
+                await run.commit()
 
         except Exception as e:
-            # Log failure for the specific step
-            await self._storage.log_step(
-                self._saga_id,
+            await state_manager.log_step(
                 step_name,
                 "act",
                 SagaStepStatus.FAILED,
                 str(e),
             )
+            if run is not None:
+                await run.commit()
             self._error = e
-            await self._compensate()
+            self._compensated = True
+            await compensator.compensate_steps(self._completed_steps)
+            if run is not None:
+                await run.commit()
             raise
 
     async def _compensate(self) -> None:
         """
-        Compensate all completed steps in reverse order with retry mechanism.
+        Mark the transaction as compensated and run compensation for all completed steps in reverse order.
+
+        Sets an internal flag to prevent repeated compensation and delegates to the compensator which applies the configured retry behavior.
         """
         # Prevent double compensation
         if self._compensated:
             return
 
         self._compensated = True
-
-        await self._storage.update_status(self._saga_id, SagaStatus.COMPENSATING)
-
-        # Load history to skip already compensated steps
-        history = await self._storage.get_step_history(self._saga_id)
-        compensated_steps = {
-            e.step_name
-            for e in history
-            if e.status == SagaStepStatus.COMPLETED and e.action == "compensate"
-        }
-
-        compensation_errors: list[
-            tuple[SagaStepHandler[ContextT, typing.Any], Exception]
-        ] = []
-
-        for step in reversed(self._completed_steps):
-            step_name = step.__class__.__name__
-
-            if step_name in compensated_steps:
-                logger.debug(f"Skipping already compensated step: {step_name}")
-                continue
-
-            try:
-                await self._storage.log_step(
-                    self._saga_id,
-                    step_name,
-                    "compensate",
-                    SagaStepStatus.STARTED,
-                )
-
-                await self._compensate_step_with_retry(step)
-
-                await self._storage.update_context(
-                    self._saga_id,
-                    self._context.to_dict(),
-                )
-                await self._storage.log_step(
-                    self._saga_id,
-                    step_name,
-                    "compensate",
-                    SagaStepStatus.COMPLETED,
-                )
-
-            except Exception as compensation_error:
-                await self._storage.log_step(
-                    self._saga_id,
-                    step_name,
-                    "compensate",
-                    SagaStepStatus.FAILED,
-                    str(compensation_error),
-                )
-                # Store both step and error for better error reporting
-                compensation_errors.append((step, compensation_error))
-
-        # If compensation failed after all retries
-        if compensation_errors:
-            for step, comp_error in compensation_errors:
-                step_name = step.__class__.__name__
-                logger.error(
-                    f"Compensation failed for step '{step_name}' after {self._compensation_retry_count} attempts. "
-                    f"Error: {type(comp_error).__name__}: {comp_error}",
-                    exc_info=comp_error,
-                )
-            # Mark as failed eventually
-            await self._storage.update_status(self._saga_id, SagaStatus.FAILED)
-        else:
-            # If all compensations succeeded (or were skipped), we effectively failed the saga transaction
-            # but successfully compensated. The saga status is FAILED.
-            await self._storage.update_status(self._saga_id, SagaStatus.FAILED)
-
-    async def _compensate_step_with_retry(
-        self,
-        step: SagaStepHandler[ContextT, typing.Any],
-    ) -> None:
-        """
-        Compensate a single step with retry mechanism and exponential backoff.
-
-        Args:
-            step: The step handler to compensate
-
-        Raises:
-            Exception: If compensation fails after all retry attempts
-        """
-        step_name = step.__class__.__name__
-
-        last_exception: Exception | None = None
-        for attempt in range(1, self._compensation_retry_count + 1):
-            try:
-                await step.compensate(self._context)
-                logger.debug(
-                    f"Successfully compensated step '{step_name}' on attempt {attempt}",
-                )
-                return
-            except Exception as e:
-                last_exception = e
-                if attempt < self._compensation_retry_count:
-                    # Calculate exponential backoff delay
-                    delay = self._compensation_retry_delay * (
-                        self._compensation_retry_backoff ** (attempt - 1)
-                    )
-                    logger.warning(
-                        f"Compensation attempt {attempt}/{self._compensation_retry_count} failed for step '{step_name}': {e}. "
-                        f"Retrying in {delay:.2f}s...",
-                    )
-                    await asyncio.sleep(delay)
-                else:
-                    logger.error(
-                        f"Compensation failed for step '{step_name}' after {self._compensation_retry_count} attempts: {e}",
-                    )
-
-        # If we get here, all retries failed
-        if last_exception:
-            raise last_exception
+        await self._compensator.compensate_steps(self._completed_steps)
 
 
 class Saga(typing.Generic[ContextT]):
     """
-    Declarative saga class that defines steps and context type.
+    Saga class that defines steps and context type.
 
-    Saga is a simple declarative class that serves as a container for:
+    Saga is a simple class that serves as a container for:
     - List of step handler types to execute in order
     - Context type (via Generic parameter)
 
@@ -433,161 +432,39 @@ class OrderSaga(Saga[OrderContext]):
                 ShipOrderStep,
             ]
 
+        saga = OrderSaga()
+
     Note:
-        Steps are validated at class creation time to ensure they handle
-        the correct context type.
+        Steps are validated at class creation time via __init_subclass__ to ensure
+        they handle the correct context type.
     """
 
-    steps: typing.ClassVar[list[typing.Type[SagaStepHandler]]]
-
-    # Steps should be defined as a class attribute in subclasses
-    # Example: steps = [Step1, Step2, ...]
-    # This is validated in __init_subclass__
+    steps: typing.ClassVar[list[type[SagaStepHandler] | Fallback]] = []
 
     def __init_subclass__(cls, **kwargs: typing.Any) -> None:
-        """
-        Validate saga steps when subclass is created.
-
-        Ensures that:
-        1. Steps attribute is defined
-        2. All steps handle the correct context type
-        """
+        """Validate steps when subclass is created."""
         super().__init_subclass__(**kwargs)
+        cls._validate_steps()
 
-        # Get the context type from Generic parameter
-        # This works by checking the __orig_bases__ for the Generic type
-        context_type: type[ContextT] | None = None
-
-        # Try to get context type from __orig_bases__
-        if hasattr(cls, "__orig_bases__"):
-            for base in cls.__orig_bases__:  # type: ignore[attr-defined]
-                # Check if this is a GenericAlias for Saga
-                if isinstance(base, types.GenericAlias) and base.__origin__ is Saga:  # type: ignore[attr-defined]
-                    args = typing.get_args(base)
-                    if args:
-                        context_type = args[0]  # type: ignore[assignment]
-                        break
-                # Fallback for older Python versions or different typing implementations
-                elif hasattr(base, "__origin__") and base.__origin__ is Saga:  # type: ignore[attr-defined]
-                    args = typing.get_args(base)
-                    if args:
-                        context_type = args[0]  # type: ignore[assignment]
-                        break
-
-        # If we couldn't determine context type from Generic, try alternative methods
-        if context_type is None:
-            # Try to get it from __class_getitem__ result
-            if hasattr(cls, "__args__") and cls.__args__:  # type: ignore[attr-defined]
-                context_type = cls.__args__[0]  # type: ignore[assignment,index]
-
-        # Check if steps attribute exists
-        if not hasattr(cls, "steps"):
-            raise TypeError(
-                f"{cls.__name__} must define 'steps' as a class attribute. "
-                "Example: steps = [Step1, Step2, ...]",
-            )
-
-        steps = getattr(cls, "steps", [])
-
-        if not isinstance(steps, list):
-            raise TypeError(
-                f"{cls.__name__}.steps must be a list of step handler types, "
-                f"got {type(steps).__name__}",
-            )
-
-        if not steps:
-            # Empty steps list is allowed (though unusual)
-            return
-
-        # Validate each step
-        for i, step_type in enumerate(steps):
-            if not isinstance(step_type, type):
-                raise TypeError(
-                    f"{cls.__name__}.steps[{i}] must be a class type, "
-                    f"got {type(step_type).__name__}",
-                )
-
-            # Check if step is a subclass of SagaStepHandler
-            if not issubclass(step_type, SagaStepHandler):
-                raise TypeError(
-                    f"{cls.__name__}.steps[{i}] ({step_type.__name__}) "
-                    "must be a subclass of SagaStepHandler",
-                )
-
-            # Try to validate context type compatibility
-            # We check the __orig_bases__ of the step handler to see what context it expects
-            if context_type is not None:
-                step_context_type: type | None = None
-
-                # Try to get step's context type from its generic bases
-                if hasattr(step_type, "__orig_bases__"):
-                    for base in step_type.__orig_bases__:  # type: ignore[attr-defined]
-                        # Check if this is a GenericAlias for SagaStepHandler
-                        if (
-                            isinstance(base, types.GenericAlias)
-                            and base.__origin__ is SagaStepHandler
-                        ):  # type: ignore[attr-defined]
-                            args = typing.get_args(base)
-                            if args:
-                                step_context_type = args[0]
-                                break
-                        # Fallback
-                        elif (
-                            hasattr(base, "__origin__")
-                            and base.__origin__ is SagaStepHandler
-                        ):  # type: ignore[attr-defined]
-                            args = typing.get_args(base)
-                            if args:
-                                step_context_type = args[0]
-                                break
-
-                # If we found the step's context type, validate it matches
-                if step_context_type is not None:
-                    # Get origin types to handle type variables and unions
-                    origin_context = getattr(context_type, "__origin__", context_type)
-                    origin_step_context = getattr(
-                        step_context_type,
-                        "__origin__",
-                        step_context_type,
-                    )
-
-                    # Check if types match exactly
-                    if origin_context != origin_step_context:
-                        # Check if they're compatible types (subclass relationship)
-                        # This allows subclasses of the expected context type
-                        if isinstance(origin_context, type) and isinstance(
-                            origin_step_context,
-                            type,
-                        ):
-                            if not issubclass(origin_context, origin_step_context):
-                                raise TypeError(
-                                    f"{cls.__name__}.steps[{i}] ({step_type.__name__}) "
-                                    f"expects context type {step_context_type.__name__}, "
-                                    f"but saga expects {context_type.__name__}. "
-                                    "Steps must handle the same context type as the saga.",
-                                )
-                        else:
-                            # For non-type origins (like TypeVar), we can't validate at class creation time
-                            # but we log a warning
-                            logger.warning(
-                                f"{cls.__name__}.steps[{i}] ({step_type.__name__}) "
-                                f"may have incompatible context type. "
-                                f"Saga expects {context_type.__name__}, "
-                                f"step expects {step_context_type.__name__}.",
-                            )
-
-    def __init__(self) -> None:
+    @classmethod
+    def _validate_steps(cls) -> None:
         """
-        Initialize a declarative saga instance.
+        Validate saga steps.
 
-        Steps must be defined as a class attribute, not passed to __init__.
+        Ensures that:
+        1. Steps is a list
+        2. All steps are valid step handler types or Fallback instances
+        3. All steps handle the correct context type
         """
-        # Ensure steps attribute exists (should be set as class attribute)
-        if not hasattr(self, "steps"):
-            raise TypeError(
-                f"{self.__class__.__name__} must define 'steps' as a class attribute. "
-                "Example: steps = [Step1, Step2, ...]",
-            )
+        # Extract context type from Generic parameter
+        context_type = SagaContextTypeExtractor.extract_from_class(cls, Saga)
+
+        # Create validator and validate steps
+        validator = SagaStepValidator(
+            saga_name=cls.__name__,
+            context_type=context_type,
+        )
+        validator.validate_steps(cls.steps)
 
     @property
     def steps_count(self) -> int:
diff --git a/src/cqrs/saga/step.py b/src/cqrs/saga/step.py
index 1abeb39..2495d1d 100644
--- a/src/cqrs/saga/step.py
+++ b/src/cqrs/saga/step.py
@@ -1,33 +1,52 @@
 from __future__ import annotations
 
 import abc
+import dataclasses
 import typing
+import uuid
 
-import pydantic
-
-from cqrs.events.event import Event
-from cqrs.response import Response
+from cqrs.events.event import IEvent
+from cqrs.response import IResponse
 from cqrs.saga.models import ContextT
 
-Resp = typing.TypeVar("Resp", bound=Response | None, covariant=True)
+Resp = typing.TypeVar("Resp", bound=IResponse | None, covariant=True)
 
 
-class SagaStepResult(pydantic.BaseModel, typing.Generic[ContextT, Resp]):
+@dataclasses.dataclass(frozen=True)
+class SagaStepResult(typing.Generic[ContextT, Resp]):
     """
     Result of a saga step execution.
 
     Contains the response from the step's act method and metadata about the step.
-    The step_type field uses typing.Any for Pydantic validation compatibility,
-    but the actual runtime type is Type[SagaStepHandler[ContextT, Resp]].
+
+    This is an internal data structure used by the saga pattern implementation.
+
+    Args:
+        response: The response object from the step (can be None)
+        step_type: Type of the step handler that produced this result
+        with_error: Whether the step resulted in an error
+        error_message: Error message if with_error is True
+        error_traceback: Error traceback lines if with_error is True
+        error_type: Type of exception if with_error is True
+        saga_id: ID of the saga this step belongs to (set by execution layer).
+                 Enables client code to trigger compensation immediately if the saga fails.
+
+    Example::
+
+        result = SagaStepResult(
+            response=response,
+            step_type=ReserveInventoryStep,
+            with_error=False
+        )
     """
 
     response: Resp
-    step_type: typing.Any  # type: ignore[assignment]  # Actual type: Type[SagaStepHandler[ContextT, Resp]]
-
+    step_type: type[SagaStepHandler[ContextT, Resp]]
     with_error: bool = False
     error_message: str | None = None
     error_traceback: list[str] | None = None
     error_type: typing.Type[Exception] | None = None
+    saga_id: uuid.UUID | None = None
 
 
 class SagaStepHandler(abc.ABC, typing.Generic[ContextT, Resp]):
@@ -93,7 +112,7 @@ async def compensate(self, context: OrderContext) -> None:
 
     def _generate_step_result(
         self,
-        response: Response | None,
+        response: IResponse | None,
         with_error: bool = False,
         error_message: str | None = None,
         error_traceback: list[str] | None = None,
@@ -125,18 +144,19 @@ def _generate_step_result(
         )
 
     @property
-    @abc.abstractmethod
-    def events(self) -> typing.List[Event]:
+    def events(self) -> typing.Sequence[IEvent]:
         """
         Get the list of domain events produced by this step.
 
+        Override in subclasses to return events generated during :meth:`act`.
+        By default returns an empty sequence.
+
         Returns:
-            A list of domain events that were generated during the execution
+            A sequence of domain events that were generated during the execution
             of the act method. These events can be emitted after the step
             completes successfully.
-
         """
-        raise NotImplementedError
+        return ()
 
     @abc.abstractmethod
     async def act(self, context: ContextT) -> SagaStepResult[ContextT, Resp]:
@@ -177,3 +197,10 @@ async def compensate(self, context: ContextT) -> None:
 
         """
         raise NotImplementedError
+
+
+__all__ = (
+    "SagaStepResult",
+    "SagaStepHandler",
+    "Resp",
+)
diff --git a/src/cqrs/saga/storage/__init__.py b/src/cqrs/saga/storage/__init__.py
index f4dc64c..cfbd22f 100644
--- a/src/cqrs/saga/storage/__init__.py
+++ b/src/cqrs/saga/storage/__init__.py
@@ -1,10 +1,11 @@
 from cqrs.saga.storage.enums import SagaStatus, SagaStepStatus
 from cqrs.saga.storage.models import SagaLogEntry
-from cqrs.saga.storage.protocol import ISagaStorage
+from cqrs.saga.storage.protocol import ISagaStorage, SagaStorageRun
 
 __all__ = [
     "SagaStatus",
     "SagaStepStatus",
     "SagaLogEntry",
     "ISagaStorage",
+    "SagaStorageRun",
 ]
diff --git a/src/cqrs/saga/storage/memory.py b/src/cqrs/saga/storage/memory.py
index acb4599..504f4a6 100644
--- a/src/cqrs/saga/storage/memory.py
+++ b/src/cqrs/saga/storage/memory.py
@@ -1,3 +1,4 @@
+import contextlib
 import datetime
 import logging
 import typing
@@ -6,26 +7,205 @@
 from cqrs.dispatcher.exceptions import SagaConcurrencyError
 from cqrs.saga.storage.enums import SagaStatus, SagaStepStatus
 from cqrs.saga.storage.models import SagaLogEntry
-from cqrs.saga.storage.protocol import ISagaStorage
+from cqrs.saga.storage.protocol import ISagaStorage, SagaStorageRun
 
 logger = logging.getLogger("cqrs.saga.storage.memory")
 
 
+class _MemorySagaStorageRun(SagaStorageRun):
+    """Run that delegates to the underlying MemorySagaStorage; commit/rollback are no-ops."""
+
+    def __init__(self, storage: "MemorySagaStorage") -> None:
+        """
+        Initialize the run and bind it to the provided MemorySagaStorage.
+
+        Parameters:
+            storage (MemorySagaStorage): Underlying in-memory storage instance used to delegate saga operations.
+        """
+        self._storage = storage
+
+    async def create_saga(
+        self,
+        saga_id: uuid.UUID,
+        name: str,
+        context: dict[str, typing.Any],
+    ) -> None:
+        """
+        Create a new saga entry in the underlying memory storage.
+
+        Parameters:
+            saga_id (uuid.UUID): Unique identifier for the saga.
+            name (str): Human-readable saga name.
+            context (dict[str, typing.Any]): Initial saga context payload.
+
+        Raises:
+            ValueError: If a saga with the same `saga_id` already exists.
+        """
+        await self._storage.create_saga(saga_id, name, context)
+
+    async def update_context(
+        self,
+        saga_id: uuid.UUID,
+        context: dict[str, typing.Any],
+        current_version: int | None = None,
+    ) -> None:
+        """
+        Update the stored context for the given saga.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga whose context will be updated.
+            context (dict[str, typing.Any]): New context to store for the saga.
+            current_version (int | None): If provided, require the stored saga version to match this value (optimistic locking).
+
+        Raises:
+            ValueError: If the saga_id does not exist.
+            SagaConcurrencyError: If current_version is provided and does not match the stored version.
+        """
+        await self._storage.update_context(saga_id, context, current_version)
+
+    async def update_status(
+        self,
+        saga_id: uuid.UUID,
+        status: SagaStatus,
+    ) -> None:
+        """
+        Update the stored status of the saga identified by `saga_id`.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga to update.
+            status (SagaStatus): New status to set for the saga.
+
+        Raises:
+            ValueError: If no saga exists with the given `saga_id`.
+        """
+        await self._storage.update_status(saga_id, status)
+
+    async def log_step(
+        self,
+        saga_id: uuid.UUID,
+        step_name: str,
+        action: typing.Literal["act", "compensate"],
+        status: SagaStepStatus,
+        details: str | None = None,
+    ) -> None:
+        """
+        Log a step entry for the given saga into the underlying storage.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga.
+            step_name (str): Name of the saga step.
+            action (Literal["act", "compensate"]): Whether the step is a forward action ("act") or a compensation ("compensate").
+            status (SagaStepStatus): Outcome status of the step.
+            details (str | None): Optional free-form details or metadata about the step.
+        """
+        await self._storage.log_step(
+            saga_id,
+            step_name,
+            action,
+            status,
+            details,
+        )
+
+    async def load_saga_state(
+        self,
+        saga_id: uuid.UUID,
+        *,
+        read_for_update: bool = False,
+    ) -> tuple[SagaStatus, dict[str, typing.Any], int]:
+        """
+        Load the current state for a saga.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga to load.
+            read_for_update (bool): If True, acquire the state for update (may be used for optimistic locking or exclusive access).
+
+        Returns:
+            tuple[SagaStatus, dict[str, typing.Any], int]: A tuple containing the saga's status, its context dictionary, and the current version number.
+        """
+        return await self._storage.load_saga_state(
+            saga_id,
+            read_for_update=read_for_update,
+        )
+
+    async def get_step_history(
+        self,
+        saga_id: uuid.UUID,
+    ) -> list[SagaLogEntry]:
+        """
+        Retrieve the step log/history for a saga.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga whose step history is requested.
+
+        Returns:
+            list[SagaLogEntry]: Saga step log entries sorted by timestamp in ascending order (oldest first). Returns an empty list if no logs exist.
+        """
+        return await self._storage.get_step_history(saga_id)
+
+    async def commit(self) -> None:
+        """
+        No-op commit for an in-memory saga run; provided to satisfy the SagaStorageRun interface.
+
+        This method intentionally performs no action because the memory storage does not require an explicit commit.
+        """
+        pass
+
+    async def rollback(self) -> None:
+        """
+        Perform no action for rollback; provided to satisfy the SagaStorageRun interface.
+        """
+        pass
+
+
 class MemorySagaStorage(ISagaStorage):
     """In-memory implementation of ISagaStorage for testing and development."""
 
     def __init__(self) -> None:
         # Structure: {saga_id: {name, status, context, created_at, updated_at, version}}
+        """
+        Initialize in-memory storage for sagas and their step logs.
+
+        Creates two internal mappings:
+        - _sagas: maps saga_id (UUID) to a dictionary containing keys `name`, `status`, `context`, `created_at`, `updated_at`, and `version`.
+        - _logs: maps saga_id (UUID) to a list of SagaLogEntry objects representing the saga's step history.
+        """
         self._sagas: dict[uuid.UUID, dict[str, typing.Any]] = {}
         # Structure: {saga_id: [SagaLogEntry, ...]}
         self._logs: dict[uuid.UUID, list[SagaLogEntry]] = {}
 
+    def create_run(
+        self,
+    ) -> contextlib.AbstractAsyncContextManager[SagaStorageRun]:
+        """
+        Provide an asynchronous context manager that yields a SagaStorageRun bound to this storage.
+
+        Returns:
+            An asynchronous context manager that yields a `SagaStorageRun` instance backed by this `MemorySagaStorage`.
+        """
+
+        @contextlib.asynccontextmanager
+        async def _run() -> typing.AsyncGenerator[SagaStorageRun, None]:
+            yield _MemorySagaStorageRun(self)
+
+        return _run()
+
     async def create_saga(
         self,
         saga_id: uuid.UUID,
         name: str,
         context: dict[str, typing.Any],
     ) -> None:
+        """
+        Create a new saga record in the in-memory store.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier for the saga; must not already exist.
+            name (str): Human-readable name for the saga.
+            context (dict[str, typing.Any]): Initial context payload for the saga.
+
+        Raises:
+            ValueError: If a saga with `saga_id` already exists.
+        """
         if saga_id in self._sagas:
             raise ValueError(f"Saga {saga_id} already exists")
 
@@ -37,6 +217,7 @@ async def create_saga(
             "created_at": now,
             "updated_at": now,
             "version": 1,
+            "recovery_attempts": 0,
         }
         self._logs[saga_id] = []
 
@@ -115,3 +296,62 @@ async def get_step_history(
             return []
         # Sort by timestamp
         return sorted(self._logs[saga_id], key=lambda x: x.timestamp)
+
+    async def get_sagas_for_recovery(
+        self,
+        limit: int,
+        max_recovery_attempts: int = 5,
+        stale_after_seconds: int | None = None,
+        saga_name: str | None = None,
+    ) -> list[uuid.UUID]:
+        """
+        Selects saga IDs eligible for recovery based on status, recovery attempts, staleness, and an optional name filter.
+
+        Parameters:
+            limit (int): Maximum number of saga IDs to return.
+            max_recovery_attempts (int): Upper bound (exclusive) on recovery attempts; only sagas with fewer attempts are considered.
+            stale_after_seconds (int | None): If provided, only sagas last updated earlier than this many seconds before now are considered; if None, staleness is ignored.
+            saga_name (str | None): If provided, only sagas with this name are considered; if None, name is not filtered.
+
+        Returns:
+            list[uuid.UUID]: Up to `limit` saga IDs sorted by oldest `updated_at` first that match the recovery criteria.
+        """
+        recoverable = (SagaStatus.RUNNING, SagaStatus.COMPENSATING)
+        now = datetime.datetime.now(datetime.timezone.utc)
+        threshold = (now - datetime.timedelta(seconds=stale_after_seconds)) if stale_after_seconds is not None else None
+        candidates = [
+            sid
+            for sid, data in self._sagas.items()
+            if data["status"] in recoverable
+            and data.get("recovery_attempts", 0) < max_recovery_attempts
+            and (threshold is None or data["updated_at"] < threshold)
+            and (saga_name is None or data["name"] == saga_name)
+        ]
+        candidates.sort(key=lambda sid: self._sagas[sid]["updated_at"])
+        return candidates[:limit]
+
+    async def increment_recovery_attempts(
+        self,
+        saga_id: uuid.UUID,
+        new_status: SagaStatus | None = None,
+    ) -> None:
+        if saga_id not in self._sagas:
+            raise ValueError(f"Saga {saga_id} not found")
+        data = self._sagas[saga_id]
+        data["recovery_attempts"] = data.get("recovery_attempts", 0) + 1
+        data["updated_at"] = datetime.datetime.now(datetime.timezone.utc)
+        data["version"] += 1
+        if new_status is not None:
+            data["status"] = new_status
+
+    async def set_recovery_attempts(
+        self,
+        saga_id: uuid.UUID,
+        attempts: int,
+    ) -> None:
+        if saga_id not in self._sagas:
+            raise ValueError(f"Saga {saga_id} not found")
+        data = self._sagas[saga_id]
+        data["recovery_attempts"] = attempts
+        data["updated_at"] = datetime.datetime.now(datetime.timezone.utc)
+        data["version"] += 1
diff --git a/src/cqrs/saga/storage/protocol.py b/src/cqrs/saga/storage/protocol.py
index 2211fca..27fcd88 100644
--- a/src/cqrs/saga/storage/protocol.py
+++ b/src/cqrs/saga/storage/protocol.py
@@ -1,4 +1,5 @@
 import abc
+import contextlib
 import typing
 import uuid
 
@@ -6,8 +7,139 @@
 from cqrs.saga.storage.models import SagaLogEntry
 
 
+class SagaStorageRun(typing.Protocol):
+    """Protocol for a scoped saga storage run (one session, checkpoint commits).
+
+    Returned by ISagaStorage.create_run(). Methods do not commit; the caller
+    must call commit() at checkpoints. Session is never exposed.
+    """
+
+    async def create_saga(
+        self,
+        saga_id: uuid.UUID,
+        name: str,
+        context: dict[str, typing.Any],
+    ) -> None:
+        """
+        Create a new saga execution record with initial PENDING status and version 1.
+
+        Parameters:
+            saga_id (uuid.UUID): Unique identifier for the saga (primary key).
+            name (str): Human-friendly name used for diagnostics and filtering.
+            context (dict[str, Any]): JSON-serializable initial saga context to persist.
+        """
+
+    async def update_context(
+        self,
+        saga_id: uuid.UUID,
+        context: dict[str, typing.Any],
+        current_version: int | None = None,
+    ) -> None:
+        """
+        Persist a snapshot of the saga's execution context, optionally using optimistic locking.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga to update.
+            context (dict[str, Any]): JSON-serializable context object to store as the new snapshot.
+            current_version (int | None): If provided, perform an optimistic-locking update that succeeds only
+                if the stored version matches this value; on success the stored version is incremented.
+
+        Raises:
+            SagaConcurrencyError: If `current_version` is provided and does not match the stored version.
+        """
+
+    async def update_status(
+        self,
+        saga_id: uuid.UUID,
+        status: SagaStatus,
+    ) -> None:
+        """
+        Set the global status for the saga identified by `saga_id`.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga to update.
+            status (SagaStatus): New global status to persist (for example RUNNING, COMPLETED, COMPENSATING).
+
+        Notes:
+            This operation does not commit the storage session; the caller must call `commit()` on the active run or session to persist the change.
+        """
+
+    async def log_step(
+        self,
+        saga_id: uuid.UUID,
+        step_name: str,
+        action: typing.Literal["act", "compensate"],
+        status: SagaStepStatus,
+        details: str | None = None,
+    ) -> None:
+        """
+        Append a step transition to the saga's execution log.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga whose log will be appended.
+            step_name (str): Logical name of the step (used for diagnostics and replay).
+            action (Literal["act", "compensate"]): Whether this entry records the primary action ("act") or its compensating action ("compensate").
+            status (SagaStepStatus): The step transition status to record (e.g., started, completed, failed, compensated).
+            details (str | None): Optional human-readable details or diagnostics about the transition.
+        """
+
+    async def load_saga_state(
+        self,
+        saga_id: uuid.UUID,
+        *,
+        read_for_update: bool = False,
+    ) -> tuple[SagaStatus, dict[str, typing.Any], int]:
+        """
+        Load the current saga execution state.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga to load.
+            read_for_update (bool): If True, acquire a database lock for update to prevent concurrent modifications.
+
+        Returns:
+            tuple[SagaStatus, dict[str, Any], int]: A tuple containing the saga's global status, the latest persisted context (JSON-serializable), and the current optimistic-locking version number.
+        """
+        ...
+
+    async def get_step_history(
+        self,
+        saga_id: uuid.UUID,
+    ) -> list[SagaLogEntry]:
+        """
+        Retrieve the chronological step log for a saga.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga whose step history to retrieve.
+
+        Returns:
+            list[SagaLogEntry]: Ordered list of step log entries for the saga, from oldest to newest.
+        """
+        ...
+
+    async def commit(self) -> None:
+        """
+        Finalize the storage run by persisting and committing all pending changes made during this session.
+
+        This method makes the run's checkpointed changes durable; the caller is responsible for invoking commit at logical checkpoints to persist session state.
+        """
+
+    async def rollback(self) -> None:
+        """
+        Abort the current storage run and revert any uncommitted changes in the session.
+
+        This releases the run's transactional state without persisting pending updates so that the storage remains as it was before the run began.
+        """
+
+
 class ISagaStorage(abc.ABC):
-    """Interface for saga persistence storage."""
+    """Interface for saga persistence storage.
+
+    Storage is responsible for persisting saga execution state so that:
+    - Saga progress (status, context, step history) survives process restarts.
+    - Recovery jobs can find interrupted sagas (RUNNING/COMPENSATING) and retry them.
+    - Optimistic locking (version) prevents lost updates when multiple workers
+      touch the same saga.
+    """
 
     @abc.abstractmethod
     async def create_saga(
@@ -16,7 +148,16 @@ async def create_saga(
         name: str,
         context: dict[str, typing.Any],
     ) -> None:
-        """Initialize a new saga in storage."""
+        """Create a new saga record in storage (initial state).
+
+        Called when a saga is started for the first time. Creates the execution
+        record with PENDING status, initial context, and version 1.
+
+        Args:
+            saga_id: Unique identifier of the saga (used as primary key).
+            name: Saga name (e.g. handler/type name) for diagnostics and filtering.
+            context: Initial context as a JSON-serializable dict (step inputs/outputs).
+        """
 
     @abc.abstractmethod
     async def update_context(
@@ -25,15 +166,22 @@ async def update_context(
         context: dict[str, typing.Any],
         current_version: int | None = None,
     ) -> None:
-        """Save saga context snapshot.
+        """Save saga context snapshot (e.g. after a step completes).
+
+        Persists the current context so recovery can resume with up-to-date data.
+        When current_version is provided, implements optimistic locking: update
+        succeeds only if the stored version equals current_version (and version
+        is incremented), otherwise a concurrent update is detected.
 
         Args:
             saga_id: The ID of the saga to update.
-            context: The new context data.
+            context: The new context data (full snapshot, JSON-serializable).
             current_version: The expected current version of the saga execution.
-                             If provided, optimistic locking will be used.
+                If provided, optimistic locking is used; if the stored version
+                differs, the update is rejected.
+
         Raises:
-            SagaConcurrencyError: If optimistic locking fails.
+            SagaConcurrencyError: If optimistic locking fails (version mismatch).
         """
 
     @abc.abstractmethod
@@ -42,7 +190,17 @@ async def update_status(
         saga_id: uuid.UUID,
         status: SagaStatus,
     ) -> None:
-        """Update saga global status."""
+        """Update the saga's global status.
+
+        Status drives lifecycle: PENDING → RUNNING → COMPLETED, or RUNNING →
+        COMPENSATING → FAILED. Used by execution and recovery to know whether
+        to run steps, compensate, or consider the saga finished.
+
+        Args:
+            saga_id: The ID of the saga to update.
+            status: New status (e.g. SagaStatus.RUNNING, SagaStatus.COMPLETED,
+                SagaStatus.COMPENSATING, SagaStatus.FAILED).
+        """
 
     @abc.abstractmethod
     async def log_step(
@@ -53,7 +211,19 @@ async def log_step(
         status: SagaStepStatus,
         details: str | None = None,
     ) -> None:
-        """Log a step transition."""
+        """Append a step transition to the saga log.
+
+        Used to record each step's outcome (started/completed/failed/compensated)
+        so that recovery can determine which steps have already been executed
+        and which need to be run or compensated.
+
+        Args:
+            saga_id: The ID of the saga this step belongs to.
+            step_name: Name of the step (must match the step handler name).
+            action: "act" for forward execution, "compensate" for compensation.
+            status: Step outcome: STARTED, COMPLETED, FAILED, or COMPENSATED.
+            details: Optional message (e.g. error text when status is FAILED).
+        """
 
     @abc.abstractmethod
     async def load_saga_state(
@@ -62,11 +232,126 @@ async def load_saga_state(
         *,
         read_for_update: bool = False,
     ) -> tuple[SagaStatus, dict[str, typing.Any], int]:
-        """Load current saga status, context, and version."""
+        """Load current saga status, context, and version.
+
+        Used by execution and recovery to restore in-memory state. When
+        read_for_update is True, the implementation may lock the row (e.g.
+        SELECT FOR UPDATE) to avoid concurrent updates.
+
+        Args:
+            saga_id: The ID of the saga to load.
+            read_for_update: If True, lock the row for update (e.g. for
+                subsequent update_context with optimistic locking).
+
+        Returns:
+            Tuple of (status, context_dict, version). context_dict is the
+            last persisted context; version is used for optimistic locking.
+        """
 
     @abc.abstractmethod
     async def get_step_history(
         self,
         saga_id: uuid.UUID,
     ) -> list[SagaLogEntry]:
-        """Get step execution history."""
+        """Return the ordered list of step log entries for the saga.
+
+        Used by recovery to determine which steps completed successfully
+        (and must be compensated in reverse order if compensating) and
+        which steps still need to be executed.
+
+        Args:
+            saga_id: The ID of the saga whose step history to load.
+
+        Returns:
+            List of SagaLogEntry in chronological order (oldest first).
+        """
+
+    @abc.abstractmethod
+    async def get_sagas_for_recovery(
+        self,
+        limit: int,
+        max_recovery_attempts: int = 5,
+        stale_after_seconds: int | None = None,
+        saga_name: str | None = None,
+    ) -> list[uuid.UUID]:
+        """Return saga IDs that are candidates for recovery.
+
+        Used by a recovery job/scheduler to find sagas that were left in
+        RUNNING or COMPENSATING (e.g. process crash) and should be retried.
+        Excludes COMPLETED and optionally limits by recovery attempts,
+        staleness, and saga name to avoid re-processing fresh or repeatedly
+        failing sagas.
+
+        Args:
+            limit: Maximum number of saga IDs to return per call.
+            max_recovery_attempts: Only include sagas with recovery_attempts
+                strictly less than this value. Sagas that have failed
+                recovery this many times can be excluded (e.g. marked FAILED).
+                Default 5.
+            stale_after_seconds: If set, only include sagas whose updated_at
+                is older than (now_utc - stale_after_seconds). Use this to
+                avoid picking sagas that are currently being executed (recently
+                updated). None means no staleness filter (backward compatible).
+            saga_name: If set, only include sagas with this name (e.g. handler
+                or type name). None means return all saga types (default).
+
+        Returns:
+            List of saga IDs (RUNNING or COMPENSATING only; FAILED/COMPLETED
+            are not included), ordered by updated_at ascending, with
+            recovery_attempts < max_recovery_attempts, and optionally
+            updated_at older than the staleness threshold and name equal to
+            saga_name when saga_name is provided.
+        """
+
+    @abc.abstractmethod
+    async def increment_recovery_attempts(
+        self,
+        saga_id: uuid.UUID,
+        new_status: SagaStatus | None = None,
+    ) -> None:
+        """Increment recovery attempt counter after a failed recovery run.
+
+        Called when recovery of a saga fails (e.g. exception). Increments
+        recovery_attempts and optionally sets status (e.g. to FAILED) so that
+        get_sagas_for_recovery can exclude this saga or limit retries.
+
+        Args:
+            saga_id: The saga that failed recovery.
+            new_status: If provided, set saga status to this value (e.g.
+                SagaStatus.FAILED) in the same atomic update.
+        """
+
+    @abc.abstractmethod
+    async def set_recovery_attempts(
+        self,
+        saga_id: uuid.UUID,
+        attempts: int,
+    ) -> None:
+        """Set recovery attempt counter to an explicit value.
+
+        Used to reset the counter after successfully recovering one of the
+        steps (e.g. set to 0), or to set it to the maximum value so that
+        get_sagas_for_recovery excludes this saga from further recovery
+        (e.g. mark as permanently failed without changing status).
+
+        Args:
+            saga_id: The saga to update.
+            attempts: The value to set recovery_attempts to (e.g. 0 to reset,
+                or max_recovery_attempts to exclude from recovery).
+        """
+
+    def create_run(
+        self,
+    ) -> contextlib.AbstractAsyncContextManager[SagaStorageRun]:
+        """
+        Create a scoped async run context for a single saga execution session with checkpointed commits.
+
+        The context manager yields a SagaStorageRun that provides the same mutation/read methods as the storage but does not commit automatically; the caller must call commit() or rollback() at desired checkpoints.
+
+        Returns:
+            contextlib.AbstractAsyncContextManager[SagaStorageRun]: Async context manager yielding a SagaStorageRun session.
+
+        Raises:
+            NotImplementedError: If the storage backend does not support scoped runs.
+        """
+        raise NotImplementedError("This storage does not support create_run()")
diff --git a/src/cqrs/saga/storage/sqlalchemy.py b/src/cqrs/saga/storage/sqlalchemy.py
index 3be685d..e8128bd 100644
--- a/src/cqrs/saga/storage/sqlalchemy.py
+++ b/src/cqrs/saga/storage/sqlalchemy.py
@@ -1,28 +1,49 @@
+import contextlib
 import datetime
 import logging
+import os
 import typing
 import uuid
 
-import sqlalchemy
-from sqlalchemy import func
-from sqlalchemy.exc import SQLAlchemyError
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
-from sqlalchemy.orm import registry
-
+import dotenv
 from cqrs.dispatcher.exceptions import SagaConcurrencyError
 from cqrs.saga.storage.enums import SagaStatus, SagaStepStatus
 from cqrs.saga.storage.models import SagaLogEntry
-from cqrs.saga.storage.protocol import ISagaStorage
+from cqrs.saga.storage.protocol import ISagaStorage, SagaStorageRun
+
+try:
+    import sqlalchemy
+    from sqlalchemy import func
+    from sqlalchemy.exc import SQLAlchemyError
+    from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+    from sqlalchemy.orm import registry
+except ImportError:
+    raise ImportError(
+        "You are trying to use SQLAlchemy saga storage implementation, "
+        "but 'sqlalchemy' is not installed. "
+        "Please install it using: pip install python-cqrs[sqlalchemy]",
+    ) from None
 
 Base = registry().generate_base()
 logger = logging.getLogger(__name__)
 
+dotenv.load_dotenv()
+
 DEFAULT_SAGA_EXECUTION_TABLE_NAME = "saga_executions"
 DEFAULT_SAGA_LOG_TABLE_NAME = "saga_logs"
 
+SAGA_EXECUTION_TABLE_NAME = os.getenv(
+    "CQRS_SAGA_EXECUTION_TABLE_NAME",
+    DEFAULT_SAGA_EXECUTION_TABLE_NAME,
+)
+SAGA_LOG_TABLE_NAME = os.getenv(
+    "CQRS_SAGA_LOG_TABLE_NAME",
+    DEFAULT_SAGA_LOG_TABLE_NAME,
+)
+
 
 class SagaExecutionModel(Base):
-    __tablename__ = DEFAULT_SAGA_EXECUTION_TABLE_NAME
+    __tablename__ = SAGA_EXECUTION_TABLE_NAME
 
     id = sqlalchemy.Column(
         sqlalchemy.Uuid,
@@ -65,10 +86,17 @@ class SagaExecutionModel(Base):
         onupdate=func.now(),
         comment="Last update timestamp",
     )
+    recovery_attempts = sqlalchemy.Column(
+        sqlalchemy.Integer,
+        nullable=False,
+        default=0,
+        server_default=sqlalchemy.text("0"),
+        comment="Number of recovery attempts",
+    )
 
 
 class SagaLogModel(Base):
-    __tablename__ = DEFAULT_SAGA_LOG_TABLE_NAME
+    __tablename__ = SAGA_LOG_TABLE_NAME
 
     id = sqlalchemy.Column(
         sqlalchemy.BigInteger(),
@@ -80,7 +108,7 @@ class SagaLogModel(Base):
     )
     saga_id = sqlalchemy.Column(
         sqlalchemy.Uuid,
-        sqlalchemy.ForeignKey(f"{DEFAULT_SAGA_EXECUTION_TABLE_NAME}.id"),
+        sqlalchemy.ForeignKey(f"{SAGA_EXECUTION_TABLE_NAME}.id"),
         nullable=False,
         comment="Saga ID",
     )
@@ -112,16 +140,284 @@ class SagaLogModel(Base):
     )
 
 
+class _SqlAlchemySagaStorageRun(SagaStorageRun):
+    """Scoped run: one session, no commit inside methods; caller calls commit()."""
+
+    def __init__(self, session: AsyncSession) -> None:
+        """
+        Initialize the run wrapper with an async SQLAlchemy session.
+
+        Parameters:
+            session (AsyncSession): The AsyncSession instance scoped to this run, used for all database operations.
+        """
+        self._session = session
+
+    async def create_saga(
+        self,
+        saga_id: uuid.UUID,
+        name: str,
+        context: dict[str, typing.Any],
+    ) -> None:
+        """
+        Create and stage a new saga execution record in the current session with initial metadata.
+
+        Creates a SagaExecutionModel for the given saga identifier with status set to PENDING, version set to 1, and recovery_attempts set to 0, and adds it to the active session without committing the transaction.
+
+        Parameters:
+            saga_id (uuid.UUID): Unique identifier for the saga execution.
+            name (str): Human-readable name of the saga.
+            context (dict[str, Any]): Initial saga context to be stored (will be serialized to the model's JSON column).
+        """
+        execution = SagaExecutionModel(
+            id=saga_id,
+            name=name,
+            status=SagaStatus.PENDING,
+            context=context,
+            version=1,
+            recovery_attempts=0,
+        )
+        self._session.add(execution)
+
+    async def update_context(
+        self,
+        saga_id: uuid.UUID,
+        context: dict[str, typing.Any],
+        current_version: int | None = None,
+    ) -> None:
+        """
+        Update the stored context for a saga and increment its version, optionally enforcing an optimistic version check.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga to update.
+            context (dict[str, typing.Any]): New serialized saga context to persist.
+            current_version (int | None): If provided, require the saga's current version to match this value before updating.
+
+        Raises:
+            SagaConcurrencyError: If an optimistic version check fails (indicating a concurrent modification) or if the saga does not exist when a version was supplied.
+        """
+        stmt = sqlalchemy.update(SagaExecutionModel).where(
+            SagaExecutionModel.id == saga_id,
+        )
+        if current_version is not None:
+            stmt = stmt.where(SagaExecutionModel.version == current_version)
+        stmt = stmt.values(
+            context=context,
+            version=SagaExecutionModel.version + 1,
+        )
+        result = await self._session.execute(stmt)
+        if result.rowcount == 0:  # type: ignore[attr-defined]
+            if current_version is not None:
+                check_stmt = sqlalchemy.select(SagaExecutionModel.id).where(
+                    SagaExecutionModel.id == saga_id,
+                )
+                check_result = await self._session.execute(check_stmt)
+                if check_result.scalar_one_or_none():
+                    raise SagaConcurrencyError(
+                        f"Saga {saga_id} was modified concurrently",
+                    )
+                raise SagaConcurrencyError(
+                    f"Saga {saga_id} was modified concurrently or does not exist",
+                )
+
+    async def update_status(
+        self,
+        saga_id: uuid.UUID,
+        status: SagaStatus,
+    ) -> None:
+        """
+        Update the stored status of a saga execution and increment its optimistic-lock version.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga execution to update.
+            status (SagaStatus): New status to set for the saga.
+
+        Note:
+            The update is executed in the active database session; a commit is required to persist the change.
+
+        Raises:
+            SagaConcurrencyError: If no row was updated (saga does not exist or was modified concurrently).
+        """
+        result = await self._session.execute(
+            sqlalchemy.update(SagaExecutionModel)
+            .where(SagaExecutionModel.id == saga_id)
+            .values(
+                status=status,
+                version=SagaExecutionModel.version + 1,
+            ),
+        )
+        if result.rowcount == 0:  # pyright: ignore[reportAttributeAccessIssue]
+            raise SagaConcurrencyError(
+                f"Saga {saga_id} does not exist or was modified concurrently",
+            )
+
+    async def log_step(
+        self,
+        saga_id: uuid.UUID,
+        step_name: str,
+        action: typing.Literal["act", "compensate"],
+        status: SagaStepStatus,
+        details: str | None = None,
+    ) -> None:
+        """
+        Record a saga step event by creating and staging a log entry in the active session.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga execution.
+            step_name (str): Name of the step being recorded.
+            action (Literal["act", "compensate"]): The performed action: "act" for normal action or "compensate" for compensation.
+            status (SagaStepStatus): The step's outcome status.
+            details (str | None): Optional free-form details or error message associated with the step.
+        """
+        log_entry = SagaLogModel(
+            saga_id=saga_id,
+            step_name=step_name,
+            action=action,
+            status=status,
+            details=details,
+        )
+        self._session.add(log_entry)
+
+    async def load_saga_state(
+        self,
+        saga_id: uuid.UUID,
+        *,
+        read_for_update: bool = False,
+    ) -> tuple[SagaStatus, dict[str, typing.Any], int]:
+        """
+        Load the current execution state for a saga.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga to load.
+            read_for_update (bool): If true, acquire a row-level lock for update.
+
+        Returns:
+            tuple[SagaStatus, dict[str, Any], int]: The saga's status, its context dictionary, and the current version.
+
+        Raises:
+            ValueError: If no saga with the given id exists.
+        """
+        stmt = sqlalchemy.select(SagaExecutionModel).where(
+            SagaExecutionModel.id == saga_id,
+        )
+        if read_for_update:
+            stmt = stmt.with_for_update()
+        result = await self._session.execute(stmt)
+        execution = result.scalars().first()
+        if not execution:
+            raise ValueError(f"Saga {saga_id} not found")
+        status_value: SagaStatus = typing.cast(SagaStatus, execution.status)
+        context_value: dict[str, typing.Any] = typing.cast(
+            dict[str, typing.Any],
+            execution.context,
+        )
+        version_value: int = typing.cast(int, execution.version)
+        return status_value, context_value, version_value
+
+    async def get_step_history(
+        self,
+        saga_id: uuid.UUID,
+    ) -> list[SagaLogEntry]:
+        """
+        Retrieve chronological step log entries for the given saga.
+
+        Parameters:
+            saga_id (uuid.UUID): UUID of the saga whose step history to fetch.
+
+        Returns:
+            list[SagaLogEntry]: List of log entries ordered by creation time. Each entry's `timestamp`
+            is normalized to UTC if not already timezone-aware.
+        """
+        result = await self._session.execute(
+            sqlalchemy.select(SagaLogModel).where(SagaLogModel.saga_id == saga_id).order_by(SagaLogModel.created_at),
+        )
+        rows = result.scalars().all()
+        return [
+            SagaLogEntry(
+                saga_id=typing.cast(uuid.UUID, row.saga_id),
+                step_name=typing.cast(str, row.step_name),
+                action=typing.cast(typing.Literal["act", "compensate"], row.action),
+                status=typing.cast(SagaStepStatus, row.status),
+                timestamp=typing.cast(
+                    datetime.datetime,
+                    row.created_at.replace(tzinfo=datetime.timezone.utc)
+                    if row.created_at.tzinfo is None
+                    else row.created_at,
+                ),
+                details=typing.cast(str | None, row.details),
+            )
+            for row in rows
+        ]
+
+    async def commit(self) -> None:
+        """
+        Commit the current transaction in the associated AsyncSession.
+        """
+        await self._session.commit()
+
+    async def rollback(self) -> None:
+        """
+        Revert all staged changes in the current session's transaction.
+
+        This aborts the in-progress transaction associated with the run's AsyncSession,
+        discarding any pending writes or flushes.
+        """
+        await self._session.rollback()
+
+
 class SqlAlchemySagaStorage(ISagaStorage):
     def __init__(self, session_factory: async_sessionmaker[AsyncSession]):
+        """
+        Initialize the SQLAlchemy-based saga storage with a factory for creating async sessions.
+
+        Parameters:
+            session_factory (async_sessionmaker[AsyncSession]): Factory that produces new AsyncSession instances used for each storage run and operation.
+        """
         self.session_factory = session_factory
 
+    def create_run(
+        self,
+    ) -> contextlib.AbstractAsyncContextManager[SagaStorageRun]:
+        """
+        Create a scoped run that yields a SagaStorageRun bound to a fresh session.
+
+        The returned context manager provides a run object whose lifecycle is tied to a single session. If an exception is raised inside the context, the run's transaction is rolled back; the session is always closed on exit.
+
+        Returns:
+            A context manager that yields a `SagaStorageRun`. On exception within the context, the run's `rollback()` is invoked and the session is closed when the context exits.
+        """
+
+        @contextlib.asynccontextmanager
+        async def _run() -> typing.AsyncGenerator[SagaStorageRun, None]:
+            async with self.session_factory() as session:
+                run = _SqlAlchemySagaStorageRun(session)
+                try:
+                    yield run
+                except BaseException:
+                    await run.rollback()
+                    raise
+
+        return _run()
+
     async def create_saga(
         self,
         saga_id: uuid.UUID,
         name: str,
         context: dict[str, typing.Any],
     ) -> None:
+        """
+        Create and persist a new saga execution record with initial metadata.
+
+        Creates a SagaExecutionModel for the given saga_id and name, sets status to PENDING,
+        version to 1, and recovery_attempts to 0, and commits it to the database.
+
+        Parameters:
+            saga_id (uuid.UUID): Unique identifier for the saga execution.
+            name (str): Human-readable saga name.
+            context (dict[str, typing.Any]): Initial saga context to store.
+
+        Raises:
+            SQLAlchemyError: If the database operation fails; the transaction is rolled back before the exception is propagated.
+        """
         async with self.session_factory() as session:
             try:
                 execution = SagaExecutionModel(
@@ -130,6 +426,7 @@ async def create_saga(
                     status=SagaStatus.PENDING,
                     context=context,
                     version=1,
+                    recovery_attempts=0,
                 )
                 session.add(execution)
                 await session.commit()
@@ -148,23 +445,17 @@ async def update_context(
                 stmt = sqlalchemy.update(SagaExecutionModel).where(
                     SagaExecutionModel.id == saga_id,
                 )
-
                 if current_version is not None:
                     stmt = stmt.where(SagaExecutionModel.version == current_version)
-                    stmt = stmt.values(
-                        context=context,
-                        version=SagaExecutionModel.version + 1,
-                    )
-                else:
-                    # If no version check, just increment version
-                    stmt = stmt.values(
-                        context=context,
-                        version=SagaExecutionModel.version + 1,
-                    )
+                stmt = stmt.values(
+                    context=context,
+                    version=SagaExecutionModel.version + 1,
+                )
 
                 result = await session.execute(stmt)
 
-                if result.rowcount == 0:
+                # Type ignore: SQLAlchemy Result from update() has rowcount attribute
+                if result.rowcount == 0:  # type: ignore[attr-defined]
                     # Check if saga exists to distinguish between "not found" and "concurrency error"
                     # But for now, we assume if rowcount is 0 and we checked version, it's concurrency
                     if current_version is not None:
@@ -289,3 +580,90 @@ async def get_step_history(
                 )
                 for row in rows
             ]
+
+    async def get_sagas_for_recovery(
+        self,
+        limit: int,
+        max_recovery_attempts: int = 5,
+        stale_after_seconds: int | None = None,
+        saga_name: str | None = None,
+    ) -> list[uuid.UUID]:
+        recoverable = (
+            SagaStatus.RUNNING,
+            SagaStatus.COMPENSATING,
+        )
+        async with self.session_factory() as session:
+            stmt = (
+                sqlalchemy.select(SagaExecutionModel.id)
+                .where(SagaExecutionModel.status.in_(recoverable))
+                .where(SagaExecutionModel.recovery_attempts < max_recovery_attempts)
+            )
+            if saga_name is not None:
+                stmt = stmt.where(SagaExecutionModel.name == saga_name)
+            if stale_after_seconds is not None:
+                threshold = datetime.datetime.now(
+                    datetime.timezone.utc,
+                ) - datetime.timedelta(
+                    seconds=stale_after_seconds,
+                )
+                stmt = stmt.where(SagaExecutionModel.updated_at < threshold)
+            stmt = stmt.order_by(SagaExecutionModel.updated_at.asc()).limit(limit)
+            result = await session.execute(stmt)
+            rows = result.scalars().all()
+            return [typing.cast(uuid.UUID, row) for row in rows]
+
+    async def increment_recovery_attempts(
+        self,
+        saga_id: uuid.UUID,
+        new_status: SagaStatus | None = None,
+    ) -> None:
+        """
+        Increment the recovery attempts counter for the given saga execution and optionally update its status.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga execution to update.
+            new_status (SagaStatus | None): If provided, set the saga's status to this value.
+
+        Raises:
+            ValueError: If no saga execution exists with the given `saga_id`.
+            SQLAlchemyError: On database errors; the transaction is rolled back and the error is propagated.
+        """
+        async with self.session_factory() as session:
+            try:
+                values: dict[str, typing.Any] = {
+                    "recovery_attempts": SagaExecutionModel.recovery_attempts + 1,
+                    "version": SagaExecutionModel.version + 1,
+                }
+                if new_status is not None:
+                    values["status"] = new_status
+                result = await session.execute(
+                    sqlalchemy.update(SagaExecutionModel).where(SagaExecutionModel.id == saga_id).values(**values),
+                )
+                if result.rowcount == 0:  # type: ignore[attr-defined]
+                    raise ValueError(f"Saga {saga_id} not found")
+                await session.commit()
+            except SQLAlchemyError:
+                await session.rollback()
+                raise
+
+    async def set_recovery_attempts(
+        self,
+        saga_id: uuid.UUID,
+        attempts: int,
+    ) -> None:
+        async with self.session_factory() as session:
+            try:
+                result = await session.execute(
+                    sqlalchemy.update(SagaExecutionModel)
+                    .where(SagaExecutionModel.id == saga_id)
+                    .values(
+                        recovery_attempts=attempts,
+                        version=SagaExecutionModel.version + 1,
+                    ),
+                )
+                if result.rowcount == 0:  # type: ignore[attr-defined]
+                    raise ValueError(f"Saga {saga_id} not found")
+                await session.commit()
+            except SQLAlchemyError:
+                await session.rollback()
+                raise
diff --git a/src/cqrs/saga/validation.py b/src/cqrs/saga/validation.py
new file mode 100644
index 0000000..688af2f
--- /dev/null
+++ b/src/cqrs/saga/validation.py
@@ -0,0 +1,296 @@
+"""Validation utilities for Saga steps and context types."""
+
+import logging
+import types
+import typing
+
+from cqrs.saga.fallback import Fallback
+from cqrs.saga.step import SagaStepHandler
+
+logger = logging.getLogger("cqrs.saga")
+
+
+class SagaContextTypeExtractor:
+    """Extracts context type from Generic type parameters."""
+
+    @staticmethod
+    def extract_from_class(klass: type, saga_base_class: type) -> type | None:
+        """
+        Extract context type from a class that inherits from a Generic base.
+
+        Args:
+            klass: The class to extract context type from
+            saga_base_class: The base Generic class (e.g., Saga)
+
+        Returns:
+            The context type if found, None otherwise
+        """
+        # Try to get context type from the class's generic parameters
+        # Check __orig_bases__ for Generic type
+        if hasattr(klass, "__orig_bases__"):
+            for base in klass.__orig_bases__:  # type: ignore[attr-defined]
+                # Check if this is a GenericAlias for Saga
+                if isinstance(base, types.GenericAlias) and base.__origin__ is saga_base_class:  # type: ignore[attr-defined]
+                    args = typing.get_args(base)
+                    if args:
+                        return args[0]  # type: ignore[return-value]
+                # Fallback for older Python versions or different typing implementations
+                elif hasattr(base, "__origin__") and base.__origin__ is saga_base_class:  # type: ignore[attr-defined]
+                    args = typing.get_args(base)
+                    if args:
+                        return args[0]  # type: ignore[return-value]
+
+        # If we couldn't determine context type from Generic, try alternative methods
+        # Try to get it from __class_getitem__ result
+        if hasattr(klass, "__args__") and klass.__args__:  # type: ignore[attr-defined]
+            return klass.__args__[0]  # type: ignore[return-value,index]
+
+        return None
+
+    @staticmethod
+    def extract_from_step(step_type: type) -> type | None:
+        """
+        Extract context type from a SagaStepHandler class.
+
+        Args:
+            step_type: The step handler class
+
+        Returns:
+            The context type if found, None otherwise
+        """
+        # Try to get step's context type from its generic bases
+        if hasattr(step_type, "__orig_bases__"):
+            for base in step_type.__orig_bases__:  # type: ignore[attr-defined]
+                # Check if this is a GenericAlias for SagaStepHandler
+                if isinstance(base, types.GenericAlias) and base.__origin__ is SagaStepHandler:  # type: ignore[attr-defined]
+                    args = typing.get_args(base)
+                    if args:
+                        return args[0]
+                # Fallback
+                elif hasattr(base, "__origin__") and base.__origin__ is SagaStepHandler:  # type: ignore[attr-defined]
+                    args = typing.get_args(base)
+                    if args:
+                        return args[0]
+
+        return None
+
+
+class ContextTypeValidator:
+    """Validates context type compatibility between saga and steps."""
+
+    @staticmethod
+    def validate(
+        saga_context_type: type,
+        step_context_type: type,
+        saga_name: str,
+        step_name: str,
+        step_index: int,
+        raise_on_mismatch: bool = True,
+    ) -> None:
+        """
+        Validate that step's context type is compatible with saga's context type.
+
+        Args:
+            saga_context_type: The context type expected by the saga
+            step_context_type: The context type expected by the step
+            saga_name: Name of the saga class (for error messages)
+            step_name: Name of the step (for error messages)
+            step_index: Index of the step in the steps list (for error messages)
+            raise_on_mismatch: If True, raise TypeError on mismatch. If False, log warning.
+
+        Raises:
+            TypeError: If types are incompatible and raise_on_mismatch is True
+        """
+        # Get origin types to handle type variables and unions
+        origin_context = getattr(saga_context_type, "__origin__", saga_context_type)
+        origin_step_context = getattr(
+            step_context_type,
+            "__origin__",
+            step_context_type,
+        )
+
+        # Check if types match exactly
+        if origin_context != origin_step_context:
+            # Check if they're compatible types (subclass relationship)
+            # This allows subclasses of the expected context type
+            if isinstance(origin_context, type) and isinstance(
+                origin_step_context,
+                type,
+            ):
+                if not issubclass(origin_context, origin_step_context):
+                    if raise_on_mismatch:
+                        raise TypeError(
+                            f"{saga_name} steps[{step_index}] ({step_name}) "
+                            f"expects context type {step_context_type.__name__}, "
+                            f"but saga expects {saga_context_type.__name__}. "
+                            "Steps must handle the same context type as the saga.",
+                        )
+                    else:
+                        logger.warning(
+                            f"{saga_name} steps[{step_index}] ({step_name}) "
+                            f"may have incompatible context type. "
+                            f"Saga expects {saga_context_type.__name__}, "
+                            f"step expects {step_context_type.__name__}.",
+                        )
+            else:
+                # For non-type origins (like TypeVar), we can't validate at runtime
+                # but we log a warning
+                step_context_name = getattr(
+                    step_context_type,
+                    "__name__",
+                    str(step_context_type),
+                )
+                if raise_on_mismatch:
+                    logger.warning(
+                        f"{saga_name} steps[{step_index}] ({step_name}) "
+                        f"may have incompatible context type. "
+                        f"Saga expects {saga_context_type.__name__}, "
+                        f"step expects {step_context_name}.",
+                    )
+                else:
+                    logger.warning(
+                        f"{saga_name} steps[{step_index}] ({step_name}) "
+                        f"may have incompatible context type. "
+                        f"Saga expects {saga_context_type.__name__}, "
+                        f"step expects {step_context_name}.",
+                    )
+
+
+class SagaStepValidator:
+    """Validates saga steps structure and types."""
+
+    def __init__(
+        self,
+        saga_name: str,
+        context_type: type | None = None,
+    ) -> None:
+        """
+        Initialize validator.
+
+        Args:
+            saga_name: Name of the saga class (for error messages)
+            context_type: Optional context type to validate against
+        """
+        self._saga_name = saga_name
+        self._context_type = context_type
+        self._context_type_extractor = SagaContextTypeExtractor()
+        self._context_type_validator = ContextTypeValidator()
+
+    def validate_steps(
+        self,
+        steps: list[type[SagaStepHandler] | Fallback],
+    ) -> None:
+        """
+        Validate saga steps.
+
+        Ensures that:
+        1. Steps is a list
+        2. All steps are valid step handler types or Fallback instances
+        3. All steps handle the correct context type
+
+        Args:
+            steps: List of steps to validate
+
+        Raises:
+            TypeError: If steps are invalid or don't match the context type
+        """
+        if not isinstance(steps, list):
+            raise TypeError(
+                f"{self._saga_name} steps must be a list of step handler types, " f"got {type(steps).__name__}",
+            )
+
+        if not steps:
+            # Empty steps list is allowed (though unusual)
+            return
+
+        # Validate each step
+        for i, step_item in enumerate(steps):
+            if isinstance(step_item, Fallback):
+                self._validate_fallback(step_item, i)
+            else:
+                self._validate_regular_step(step_item, i)
+
+    def _validate_fallback(self, fallback_item: Fallback, index: int) -> None:
+        """Validate a Fallback wrapper."""
+        # Validate Fallback structure
+        if not isinstance(fallback_item.step, type):
+            raise TypeError(
+                f"{self._saga_name} steps[{index}].step must be a class type, "
+                f"got {type(fallback_item.step).__name__}",
+            )
+        if not isinstance(fallback_item.fallback, type):
+            raise TypeError(
+                f"{self._saga_name} steps[{index}].fallback must be a class type, "
+                f"got {type(fallback_item.fallback).__name__}",
+            )
+
+        # Check that step and fallback are SagaStepHandler subclasses
+        if not issubclass(fallback_item.step, SagaStepHandler):
+            raise TypeError(
+                f"{self._saga_name} steps[{index}].step ({fallback_item.step.__name__}) "
+                "must be a subclass of SagaStepHandler",
+            )
+        if not issubclass(fallback_item.fallback, SagaStepHandler):
+            raise TypeError(
+                f"{self._saga_name} steps[{index}].fallback ({fallback_item.fallback.__name__}) "
+                "must be a subclass of SagaStepHandler",
+            )
+
+        # No nested Fallback support
+        if isinstance(fallback_item.fallback, Fallback):
+            raise TypeError(
+                f"{self._saga_name} steps[{index}].fallback cannot be a Fallback instance. "
+                "Nested Fallback is not supported.",
+            )
+
+        # Validate context types for both step and fallback
+        if self._context_type is not None:
+            for step_type, step_name in [
+                (fallback_item.step, "step"),
+                (fallback_item.fallback, "fallback"),
+            ]:
+                step_context_type = self._context_type_extractor.extract_from_step(
+                    step_type,
+                )
+                if step_context_type is not None:
+                    self._context_type_validator.validate(
+                        saga_context_type=self._context_type,
+                        step_context_type=step_context_type,
+                        saga_name=self._saga_name,
+                        step_name=step_type.__name__,
+                        step_index=index,
+                        raise_on_mismatch=True,
+                    )
+
+    def _validate_regular_step(
+        self,
+        step_item: type[SagaStepHandler],
+        index: int,
+    ) -> None:
+        """Validate a regular step handler."""
+        if not isinstance(step_item, type):
+            raise TypeError(
+                f"{self._saga_name} steps[{index}] must be a class type or Fallback instance, "
+                f"got {type(step_item).__name__}",
+            )
+
+        # Check if step is a subclass of SagaStepHandler
+        if not issubclass(step_item, SagaStepHandler):
+            raise TypeError(
+                f"{self._saga_name} steps[{index}] ({step_item.__name__}) " "must be a subclass of SagaStepHandler",
+            )
+
+        # Validate context type compatibility
+        if self._context_type is not None:
+            step_context_type = self._context_type_extractor.extract_from_step(
+                step_item,
+            )
+            if step_context_type is not None:
+                self._context_type_validator.validate(
+                    saga_context_type=self._context_type,
+                    step_context_type=step_context_type,
+                    saga_name=self._saga_name,
+                    step_name=step_item.__name__,
+                    step_index=index,
+                    raise_on_mismatch=True,
+                )
diff --git a/src/cqrs/serializers/__init__.py b/src/cqrs/serializers/__init__.py
index 9017591..b80c01d 100644
--- a/src/cqrs/serializers/__init__.py
+++ b/src/cqrs/serializers/__init__.py
@@ -1,7 +1,3 @@
 from cqrs.serializers.default import default_serializer
-from cqrs.serializers.protobuf import protobuf_value_serializer
 
-__all__ = (
-    "protobuf_value_serializer",
-    "default_serializer",
-)
\ No newline at end of file
+__all__ = ("default_serializer",)
diff --git a/src/cqrs/serializers/default.py b/src/cqrs/serializers/default.py
index a549d68..deb4eb7 100644
--- a/src/cqrs/serializers/default.py
+++ b/src/cqrs/serializers/default.py
@@ -1,8 +1,24 @@
 import typing
 
 import orjson
-import pydantic
 
 
-def default_serializer(message: pydantic.BaseModel) -> typing.ByteString:
-    return orjson.dumps(message.model_dump(mode="json"))
+def default_serializer(message: typing.Any) -> typing.ByteString:
+    """
+    Default serializer for messages.
+
+    Works with any object that has a to_dict() method (interface-based approach).
+    Falls back to model_dump() if available, otherwise serializes as-is.
+
+    Args:
+        message: Object to serialize. Should implement to_dict() method.
+
+    Returns:
+        Serialized message as bytes.
+    """
+    if hasattr(message, "to_dict"):
+        return orjson.dumps(message.to_dict())
+    elif hasattr(message, "model_dump"):
+        return orjson.dumps(message.model_dump(mode="json"))
+    else:
+        return orjson.dumps(message)
diff --git a/src/cqrs/serializers/protobuf.py b/src/cqrs/serializers/protobuf.py
deleted file mode 100644
index 4f94f0c..0000000
--- a/src/cqrs/serializers/protobuf.py
+++ /dev/null
@@ -1,39 +0,0 @@
-import os
-import typing
-
-import dotenv
-from confluent_kafka import schema_registry, serialization
-from confluent_kafka.schema_registry import protobuf
-
-import cqrs
-
-dotenv.load_dotenv()
-
-KAFKA_SCHEMA_REGISTRY_URL = os.getenv(
-    "KAFKA_SCHEMA_REGISTRY_URL",
-    "http://localhost:8085",
-)
-
-
-def protobuf_value_serializer(
-    event: cqrs.NotificationEvent,
-) -> typing.ByteString | None:
-    """
-    Serialize CQRS event model into protobuf message.
-    """
-    protobuf_event = event.proto()
-    schema_registry_client = schema_registry.SchemaRegistryClient(
-        {"url": KAFKA_SCHEMA_REGISTRY_URL},
-    )
-    protobuf_serializer = protobuf.ProtobufSerializer(
-        protobuf_event.__class__,
-        schema_registry_client,
-        {"use.deprecated.format": False},
-    )
-
-    context = serialization.SerializationContext(
-        event.topic,
-        serialization.MessageField.VALUE,
-    )
-
-    return protobuf_serializer(protobuf_event, context)
diff --git a/src/cqrs/types.py b/src/cqrs/types.py
index 6fb76cc..c4cfbb2 100644
--- a/src/cqrs/types.py
+++ b/src/cqrs/types.py
@@ -1,18 +1,11 @@
 """
 Type definitions for CQRS framework.
 
-This module contains common type variables used throughout the framework.
-It is placed at the bottom of the dependency hierarchy to avoid circular imports.
+This module re-exports common type variables (ReqT, ResT) from
+cqrs.requests.request for backward compatibility. Defining ReqT/ResT in
+request.py avoids circular import with request_handler.
 """
 
-import typing
+from cqrs.requests.request import ReqT, ResT
 
-from cqrs.requests.request import Request
-from cqrs.response import Response
-
-# Type variable for request types (contravariant - can accept subtypes)
-ReqT = typing.TypeVar("ReqT", bound=Request, contravariant=True)
-
-# Type variable for response types (covariant - can return subtypes)
-# Can be Response or None
-ResT = typing.TypeVar("ResT", bound=Response | None, covariant=True)
+__all__ = ("ReqT", "ResT")
diff --git a/tests/benchmarks/__init__.py b/tests/benchmarks/__init__.py
new file mode 100644
index 0000000..d6cb596
--- /dev/null
+++ b/tests/benchmarks/__init__.py
@@ -0,0 +1 @@
+# Benchmark package; shared helpers in conftest.py
diff --git a/tests/benchmarks/conftest.py b/tests/benchmarks/conftest.py
new file mode 100644
index 0000000..603269c
--- /dev/null
+++ b/tests/benchmarks/conftest.py
@@ -0,0 +1,72 @@
+"""Shared fixtures and legacy storage classes for benchmarks."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import os
+
+import pytest
+from sqlalchemy.ext.asyncio import create_async_engine
+
+from cqrs.saga.storage.memory import MemorySagaStorage
+from cqrs.saga.storage.protocol import SagaStorageRun
+from cqrs.saga.storage.sqlalchemy import Base, SqlAlchemySagaStorage
+
+
+class MemorySagaStorageLegacy(MemorySagaStorage):
+    """Memory storage without create_run: forces legacy path (commit per call)."""
+
+    def create_run(
+        self,
+    ) -> contextlib.AbstractAsyncContextManager[SagaStorageRun]:
+        """Raise NotImplementedError so benchmarks use the legacy commit-per-call path."""
+        raise NotImplementedError("Legacy storage: create_run disabled for benchmark")
+
+
+class SqlAlchemySagaStorageLegacy(SqlAlchemySagaStorage):
+    """SQLAlchemy storage without create_run: forces legacy path (commit per call)."""
+
+    def create_run(
+        self,
+    ) -> contextlib.AbstractAsyncContextManager[SagaStorageRun]:
+        """Raise NotImplementedError so benchmarks use the legacy commit-per-call path."""
+        raise NotImplementedError("Legacy storage: create_run disabled for benchmark")
+
+
+@pytest.fixture(scope="session")
+def database_dsn() -> str | None:
+    """DATABASE_DSN from environment (set in CI by pytest-config.ini)."""
+    return os.environ.get("DATABASE_DSN") or None
+
+
+@pytest.fixture(scope="session")
+def saga_benchmark_loop_and_engine(database_dsn: str | None):
+    """
+    One event loop and one async engine for the whole benchmark session.
+    Used by saga SQLAlchemy benchmarks so connection setup/teardown is not measured.
+    Fails (no skip) if DATABASE_DSN is unset or connection fails, so CI shows the real error.
+    """
+    if not database_dsn:
+        pytest.fail("DATABASE_DSN not set; set it in CI (e.g. in codspeed.yml env) to run saga SQLAlchemy benchmarks")
+
+    loop = asyncio.new_event_loop()
+    engine = create_async_engine(
+        database_dsn,
+        pool_pre_ping=True,
+        pool_size=2,
+        max_overflow=4,
+        echo=False,
+    )
+
+    async def ensure_tables() -> None:
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+
+    loop.run_until_complete(ensure_tables())
+
+    try:
+        yield (loop, engine)
+    finally:
+        loop.run_until_complete(engine.dispose())
+        loop.close()
diff --git a/tests/benchmarks/dataclasses/__init__.py b/tests/benchmarks/dataclasses/__init__.py
new file mode 100644
index 0000000..85f9be8
--- /dev/null
+++ b/tests/benchmarks/dataclasses/__init__.py
@@ -0,0 +1 @@
+"""Dataclass-based benchmarks (DCRequest, DCResponse, DCEvent)."""
diff --git a/tests/benchmarks/dataclasses/test_benchmark_cor_request_handler.py b/tests/benchmarks/dataclasses/test_benchmark_cor_request_handler.py
new file mode 100644
index 0000000..82dc2af
--- /dev/null
+++ b/tests/benchmarks/dataclasses/test_benchmark_cor_request_handler.py
@@ -0,0 +1,148 @@
+"""Benchmarks for Chain of Responsibility (dataclass DCRequest/DCResponse)."""
+
+import asyncio
+import dataclasses
+import typing
+
+import cqrs
+import di
+import pytest
+from cqrs.requests import bootstrap
+from cqrs.requests.cor_request_handler import CORRequestHandler
+
+
+@dataclasses.dataclass
+class TRequest(cqrs.DCRequest):
+    method: str
+    user_id: str
+
+
+@dataclasses.dataclass
+class TResult(cqrs.DCResponse):
+    success: bool
+    handler_name: str
+    message: str = ""
+
+
+class HandlerA(CORRequestHandler[TRequest, TResult | None]):
+    @property
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
+        return []
+
+    async def handle(self, request: TRequest) -> TResult | None:
+        if request.method == "method_a":
+            return TResult(
+                success=True,
+                handler_name="HandlerA",
+                message=f"Processed method_a for {request.user_id}",
+            )
+        return await self.next(request)
+
+
+class HandlerB(CORRequestHandler[TRequest, TResult | None]):
+    @property
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
+        return []
+
+    async def handle(self, request: TRequest) -> TResult | None:
+        if request.method == "method_b":
+            return TResult(
+                success=True,
+                handler_name="HandlerB",
+                message=f"Processed method_b for {request.user_id}",
+            )
+        return await self.next(request)
+
+
+class HandlerC(CORRequestHandler[TRequest, TResult | None]):
+    @property
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
+        return []
+
+    async def handle(self, request: TRequest) -> TResult | None:
+        if request.method == "method_c":
+            return TResult(
+                success=True,
+                handler_name="HandlerC",
+                message=f"Processed method_c for {request.user_id}",
+            )
+        return await self.next(request)
+
+
+class DefaultHandler(CORRequestHandler[TRequest, TResult | None]):
+    @property
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
+        return []
+
+    async def handle(self, request: TRequest) -> TResult | None:
+        return TResult(
+            success=False,
+            handler_name="DefaultHandler",
+            message=f"Unsupported method: {request.method}",
+        )
+
+
+def cor_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(
+        TRequest,
+        [HandlerA, HandlerB, HandlerC, DefaultHandler],
+    )
+
+
+@pytest.fixture
+def cor_mediator():
+    return bootstrap.bootstrap(
+        di_container=di.Container(),
+        commands_mapper=cor_mapper,
+    )
+
+
+@pytest.mark.benchmark
+def test_benchmark_cor_first_handler(cor_mediator, benchmark):
+    """Benchmark CoR when first handler in chain handles the request."""
+
+    async def run():
+        return await cor_mediator.send(TRequest(method="method_a", user_id="user_1"))
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_cor_second_handler(cor_mediator, benchmark):
+    """Benchmark CoR when second handler in chain handles the request."""
+
+    async def run():
+        return await cor_mediator.send(TRequest(method="method_b", user_id="user_1"))
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_cor_third_handler(cor_mediator, benchmark):
+    """Benchmark CoR when third handler in chain handles the request."""
+
+    async def run():
+        return await cor_mediator.send(TRequest(method="method_c", user_id="user_1"))
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_cor_default_handler(cor_mediator, benchmark):
+    """Benchmark CoR when only default (last) handler handles the request."""
+
+    async def run():
+        return await cor_mediator.send(TRequest(method="other", user_id="user_1"))
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_cor_ten_requests_first_handler(cor_mediator, benchmark):
+    """Benchmark CoR handling 10 requests (first handler)."""
+
+    async def run():
+        for i in range(10):
+            await cor_mediator.send(TRequest(method="method_a", user_id=f"user_{i}"))
+
+    benchmark(lambda: asyncio.run(run()))
diff --git a/tests/benchmarks/dataclasses/test_benchmark_event_handler_chain.py b/tests/benchmarks/dataclasses/test_benchmark_event_handler_chain.py
new file mode 100644
index 0000000..feb6dbc
--- /dev/null
+++ b/tests/benchmarks/dataclasses/test_benchmark_event_handler_chain.py
@@ -0,0 +1,139 @@
+"""Benchmarks: 3-level event chain, volume >> semaphore (parallel follow-ups). Dataclass events."""
+
+import asyncio
+import dataclasses
+
+import pytest
+
+from cqrs.events import DCDomainEvent, EventEmitter, EventHandler, EventMap
+from cqrs.events.event import IEvent
+from cqrs.events.event_processor import EventProcessor
+from cqrs.container.protocol import Container
+
+
+@dataclasses.dataclass(frozen=True)
+class _EventL1(DCDomainEvent):
+    id_: str
+
+
+@dataclasses.dataclass(frozen=True)
+class _EventL2(DCDomainEvent):
+    id_: str
+
+
+@dataclasses.dataclass(frozen=True)
+class _EventL3(DCDomainEvent):
+    id_: str
+
+
+# Number of follow-ups per level so total events >> semaphore
+FAN_OUT_L1 = 10
+FAN_OUT_L2 = 5
+SEMAPHORE_SIZE = 4
+
+
+class _HandlerL1(EventHandler[_EventL1]):
+    def __init__(self) -> None:
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> tuple[IEvent, ...]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: _EventL1) -> None:
+        self._follow_ups = [_EventL2(id_=f"l2_{event.id_}_{i}") for i in range(FAN_OUT_L1)]
+
+
+class _HandlerL2(EventHandler[_EventL2]):
+    def __init__(self) -> None:
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> tuple[IEvent, ...]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: _EventL2) -> None:
+        self._follow_ups = [_EventL3(id_=f"l3_{event.id_}_{i}") for i in range(FAN_OUT_L2)]
+
+
+class _HandlerL3(EventHandler[_EventL3]):
+    async def handle(self, event: _EventL3) -> None:
+        pass
+
+
+class _ChainContainer(Container[object]):
+    def __init__(self) -> None:
+        self._external: object | None = None
+
+    @property
+    def external_container(self) -> object:
+        return self._external  # type: ignore[return-value]
+
+    def attach_external_container(self, container: object) -> None:
+        self._external = container
+
+    async def resolve(self, type_: type) -> EventHandler[IEvent]:
+        # Return fresh instances per resolve so stateful handlers (_HandlerL1/_HandlerL2
+        # _follow_ups) are not shared across concurrent event handling (parallel benchmarks).
+        if type_ is _HandlerL1:
+            return _HandlerL1()  # type: ignore[return-value]
+        if type_ is _HandlerL2:
+            return _HandlerL2()  # type: ignore[return-value]
+        if type_ is _HandlerL3:
+            return _HandlerL3()  # type: ignore[return-value]
+        raise KeyError(type_)
+
+
+def _make_processor(parallel: bool) -> EventProcessor:
+    event_map = EventMap()
+    event_map.bind(_EventL1, _HandlerL1)
+    event_map.bind(_EventL2, _HandlerL2)
+    event_map.bind(_EventL3, _HandlerL3)
+    container = _ChainContainer()
+    emitter = EventEmitter(event_map=event_map, container=container)
+    return EventProcessor(
+        event_map=event_map,
+        event_emitter=emitter,
+        max_concurrent_event_handlers=SEMAPHORE_SIZE,
+        concurrent_event_handle_enable=parallel,
+    )
+
+
+@pytest.fixture
+def event_processor_chain_parallel() -> EventProcessor:
+    """EventProcessor with 3-level chain, parallel, semaphore=4 (dataclass events)."""
+    return _make_processor(parallel=True)
+
+
+@pytest.mark.benchmark
+def test_benchmark_event_chain_three_levels_parallel(
+    benchmark,
+    event_processor_chain_parallel: EventProcessor,
+) -> None:
+    """Benchmark: 1 root event -> 10 L2 -> 50 L3 (61 total), semaphore 4 (dataclass)."""
+    processor = event_processor_chain_parallel
+
+    async def run() -> None:
+        await processor.emit_events([_EventL1(id_="root")])
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.fixture
+def event_processor_chain_sequential() -> EventProcessor:
+    """EventProcessor with 3-level chain, sequential (dataclass events)."""
+    return _make_processor(parallel=False)
+
+
+@pytest.mark.benchmark
+def test_benchmark_event_chain_three_levels_sequential(
+    benchmark,
+    event_processor_chain_sequential: EventProcessor,
+) -> None:
+    """Benchmark: same 3-level chain, sequential (BFS), dataclass events."""
+    processor = event_processor_chain_sequential
+
+    async def run() -> None:
+        await processor.emit_events([_EventL1(id_="root")])
+
+    benchmark(lambda: asyncio.run(run()))
diff --git a/tests/benchmarks/dataclasses/test_benchmark_event_handling.py b/tests/benchmarks/dataclasses/test_benchmark_event_handling.py
new file mode 100644
index 0000000..178ad98
--- /dev/null
+++ b/tests/benchmarks/dataclasses/test_benchmark_event_handling.py
@@ -0,0 +1,74 @@
+"""Benchmarks for event handling performance (dataclass DCEvent)."""
+
+import asyncio
+import dataclasses
+import typing
+
+import cqrs
+import di
+import pytest
+from cqrs.events import bootstrap
+
+
+@dataclasses.dataclass(frozen=True)
+class UserJoinedEvent(cqrs.DCEvent):
+    user_id: str
+    meeting_id: str
+
+
+class UserJoinedEventHandler(cqrs.EventHandler[UserJoinedEvent]):
+    def __init__(self):
+        self.processed_events: typing.List[UserJoinedEvent] = []
+
+    async def handle(self, event: UserJoinedEvent) -> None:
+        self.processed_events.append(event)
+
+
+def events_mapper(mapper: cqrs.EventMap) -> None:
+    mapper.bind(UserJoinedEvent, UserJoinedEventHandler)
+
+
+@pytest.fixture
+def event_mediator():
+    return bootstrap.bootstrap(
+        di_container=di.Container(),
+        events_mapper=events_mapper,
+    )
+
+
+@pytest.mark.benchmark
+def test_benchmark_event_processing(benchmark, event_mediator):
+    """Benchmark event processing performance."""
+    event = UserJoinedEvent(user_id="user_1", meeting_id="meeting_1")
+
+    async def run():
+        await event_mediator.send(event)
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_multiple_events(benchmark, event_mediator):
+    """Benchmark processing multiple events in sequence."""
+    events = [UserJoinedEvent(user_id=f"user_{i}", meeting_id="meeting_1") for i in range(10)]
+
+    async def run():
+        for evt in events:
+            await event_mediator.send(evt)
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_notification_event(benchmark):
+    """Benchmark notification event creation and serialization."""
+
+    def run():
+        event = cqrs.NotificationEvent[UserJoinedEvent](
+            event_name="UserJoined",
+            topic="test_topic",
+            payload=UserJoinedEvent(user_id="user_1", meeting_id="meeting_1"),
+        )
+        return event.to_dict()
+
+    benchmark(run)
diff --git a/tests/benchmarks/dataclasses/test_benchmark_request_handling.py b/tests/benchmarks/dataclasses/test_benchmark_request_handling.py
new file mode 100644
index 0000000..cc20604
--- /dev/null
+++ b/tests/benchmarks/dataclasses/test_benchmark_request_handling.py
@@ -0,0 +1,104 @@
+"""Benchmarks for request handling performance (dataclass DCRequest/DCResponse)."""
+
+import asyncio
+import dataclasses
+import typing
+from collections import defaultdict
+
+import cqrs
+import di
+import pytest
+from cqrs.requests import bootstrap
+
+STORAGE = defaultdict[str, typing.List[str]](lambda: [])
+
+
+@dataclasses.dataclass
+class JoinMeetingCommand(cqrs.DCRequest):
+    user_id: str
+    meeting_id: str
+
+
+@dataclasses.dataclass
+class ReadMeetingQuery(cqrs.DCRequest):
+    meeting_id: str
+
+
+@dataclasses.dataclass
+class ReadMeetingQueryResult(cqrs.DCResponse):
+    users: list[str]
+
+
+class JoinMeetingCommandHandler(cqrs.RequestHandler[JoinMeetingCommand, None]):
+    @property
+    def events(self):
+        return []
+
+    async def handle(self, request: JoinMeetingCommand) -> None:
+        STORAGE[request.meeting_id].append(request.user_id)
+
+
+class ReadMeetingQueryHandler(
+    cqrs.RequestHandler[ReadMeetingQuery, ReadMeetingQueryResult],
+):
+    @property
+    def events(self):
+        return []
+
+    async def handle(self, request: ReadMeetingQuery) -> ReadMeetingQueryResult:
+        return ReadMeetingQueryResult(users=STORAGE[request.meeting_id])
+
+
+def command_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(JoinMeetingCommand, JoinMeetingCommandHandler)
+
+
+def query_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(ReadMeetingQuery, ReadMeetingQueryHandler)
+
+
+@pytest.fixture
+def mediator():
+    return bootstrap.bootstrap(
+        di_container=di.Container(),
+        queries_mapper=query_mapper,
+        commands_mapper=command_mapper,
+    )
+
+
+@pytest.mark.benchmark
+def test_benchmark_command_handling(benchmark, mediator):
+    """Benchmark command handling performance."""
+    STORAGE.clear()
+    command = JoinMeetingCommand(user_id="user_1", meeting_id="meeting_1")
+
+    async def run():
+        await mediator.send(command)
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_query_handling(benchmark, mediator):
+    """Benchmark query handling performance."""
+    STORAGE.clear()
+    STORAGE["meeting_1"] = ["user_1", "user_2", "user_3"]
+    query = ReadMeetingQuery(meeting_id="meeting_1")
+
+    async def run():
+        return await mediator.send(query)
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_multiple_commands(benchmark, mediator):
+    """Benchmark handling multiple commands in sequence."""
+    STORAGE.clear()
+    commands = [JoinMeetingCommand(user_id=f"user_{i}", meeting_id="meeting_2") for i in range(10)]
+
+    async def run():
+        for cmd in commands:
+            await mediator.send(cmd)
+
+    benchmark(lambda: asyncio.run(run()))
diff --git a/tests/benchmarks/dataclasses/test_benchmark_saga_fallback.py b/tests/benchmarks/dataclasses/test_benchmark_saga_fallback.py
new file mode 100644
index 0000000..8e4a91f
--- /dev/null
+++ b/tests/benchmarks/dataclasses/test_benchmark_saga_fallback.py
@@ -0,0 +1,129 @@
+"""Benchmarks for Saga with Fallback (dataclass DCResponse)."""
+
+import asyncio
+
+import pytest
+from cqrs.adapters.circuit_breaker import AioBreakerAdapter
+from cqrs.events.event import Event
+from cqrs.saga.fallback import Fallback
+from cqrs.saga.saga import Saga
+from cqrs.saga.step import SagaStepHandler, SagaStepResult
+from cqrs.saga.storage.memory import MemorySagaStorage
+
+from .test_benchmark_saga_memory import (
+    OrderContext,
+    ProcessPaymentStep,
+    ReserveInventoryResponse,
+    ReserveInventoryStep,
+    SagaContainer,
+    ShipOrderStep,
+)
+
+
+class FallbackReserveStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+    """Fallback step used when primary fails (not used in happy-path benchmark)."""
+
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        response = ReserveInventoryResponse(
+            inventory_id=f"fallback_inv_{context.order_id}",
+            reserved=True,
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        pass
+
+
+@pytest.fixture
+def saga_container_fallback() -> SagaContainer:
+    container = SagaContainer()
+    container.register(ReserveInventoryStep, ReserveInventoryStep())
+    container.register(FallbackReserveStep, FallbackReserveStep())
+    container.register(ProcessPaymentStep, ProcessPaymentStep())
+    container.register(ShipOrderStep, ShipOrderStep())
+    return container
+
+
+@pytest.fixture
+def memory_storage() -> MemorySagaStorage:
+    return MemorySagaStorage()
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_fallback_without_circuit_breaker(
+    benchmark,
+    saga_container_fallback: SagaContainer,
+    memory_storage: MemorySagaStorage,
+):
+    """Benchmark saga with Fallback step (no circuit breaker). Primary step runs."""
+
+    class SagaWithFallbackNoCB(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=ReserveInventoryStep,
+                fallback=FallbackReserveStep,
+                circuit_breaker=None,
+            ),
+            ProcessPaymentStep,
+            ShipOrderStep,
+        ]
+
+    saga = SagaWithFallbackNoCB()
+
+    async def run() -> None:
+        context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+        async with saga.transaction(
+            context=context,
+            container=saga_container_fallback,
+            storage=memory_storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_fallback_with_aiobreaker_adapter(
+    benchmark,
+    saga_container_fallback: SagaContainer,
+    memory_storage: MemorySagaStorage,
+):
+    """Benchmark saga with Fallback step and AioBreakerAdapter circuit breaker."""
+
+    circuit_breaker = AioBreakerAdapter(fail_max=5, timeout_duration=60)
+
+    class SagaWithFallbackWithCB(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=ReserveInventoryStep,
+                fallback=FallbackReserveStep,
+                circuit_breaker=circuit_breaker,
+            ),
+            ProcessPaymentStep,
+            ShipOrderStep,
+        ]
+
+    saga = SagaWithFallbackWithCB()
+
+    async def run() -> None:
+        context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+        async with saga.transaction(
+            context=context,
+            container=saga_container_fallback,
+            storage=memory_storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
diff --git a/tests/benchmarks/dataclasses/test_benchmark_saga_memory.py b/tests/benchmarks/dataclasses/test_benchmark_saga_memory.py
new file mode 100644
index 0000000..a846b34
--- /dev/null
+++ b/tests/benchmarks/dataclasses/test_benchmark_saga_memory.py
@@ -0,0 +1,358 @@
+"""Benchmarks for Saga with memory storage (dataclass DCResponse).
+
+- Benchmarks named *_run_* use the scoped run path (create_run, checkpoint commits).
+- Benchmarks named *_legacy_* use the legacy path (no create_run, commit per storage call).
+"""
+
+import asyncio
+import dataclasses
+import typing
+
+import pytest
+from cqrs.events.event import Event
+from cqrs.response import DCResponse
+from cqrs.saga.models import SagaContext
+from cqrs.saga.saga import Saga
+from cqrs.saga.step import SagaStepHandler, SagaStepResult
+from cqrs.saga.storage.memory import MemorySagaStorage
+
+from ..conftest import MemorySagaStorageLegacy
+
+
+@dataclasses.dataclass
+class OrderContext(SagaContext):
+    order_id: str
+    user_id: str
+    amount: float
+
+
+@dataclasses.dataclass
+class ReserveInventoryResponse(DCResponse):
+    inventory_id: str
+    reserved: bool
+
+
+@dataclasses.dataclass
+class ProcessPaymentResponse(DCResponse):
+    payment_id: str
+    charged: bool
+
+
+@dataclasses.dataclass
+class ShipOrderResponse(DCResponse):
+    shipment_id: str
+    shipped: bool
+
+
+class ReserveInventoryStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        response = ReserveInventoryResponse(
+            inventory_id=f"inv_{context.order_id}",
+            reserved=True,
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        pass
+
+
+class ProcessPaymentStep(SagaStepHandler[OrderContext, ProcessPaymentResponse]):
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ProcessPaymentResponse]:
+        response = ProcessPaymentResponse(
+            payment_id=f"pay_{context.order_id}",
+            charged=True,
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        pass
+
+
+class ShipOrderStep(SagaStepHandler[OrderContext, ShipOrderResponse]):
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ShipOrderResponse]:
+        response = ShipOrderResponse(
+            shipment_id=f"ship_{context.order_id}",
+            shipped=True,
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        pass
+
+
+class SagaContainer:
+    """Simple container that resolves saga step handlers."""
+
+    def __init__(self) -> None:
+        self._handlers: dict[type, SagaStepHandler] = {}
+        self._external_container: typing.Any = None
+
+    def register(self, handler_type: type, handler: SagaStepHandler) -> None:
+        self._handlers[handler_type] = handler
+
+    @property
+    def external_container(self) -> typing.Any:
+        return self._external_container
+
+    def attach_external_container(self, container: typing.Any) -> None:
+        self._external_container = container
+
+    async def resolve(self, type_: type) -> typing.Any:
+        if type_ not in self._handlers:
+            self._handlers[type_] = type_()
+        return self._handlers[type_]
+
+
+@pytest.fixture
+def saga_container() -> SagaContainer:
+    container = SagaContainer()
+    container.register(ReserveInventoryStep, ReserveInventoryStep())
+    container.register(ProcessPaymentStep, ProcessPaymentStep())
+    container.register(ShipOrderStep, ShipOrderStep())
+    return container
+
+
+@pytest.fixture
+def memory_storage() -> MemorySagaStorage:
+    """
+    Provide a fresh in-memory saga storage instance for tests and benchmarks.
+
+    Returns:
+        MemorySagaStorage: A new MemorySagaStorage instance.
+    """
+    return MemorySagaStorage()
+
+
+@pytest.fixture
+def memory_storage_legacy() -> MemorySagaStorageLegacy:
+    """
+    Provide a legacy in-memory saga storage that does not support scoped runs.
+
+    Returns:
+        MemorySagaStorageLegacy: An in-memory saga storage whose `create_run` is disabled (raises `NotImplementedError`) for legacy-path benchmarks.
+    """
+    return MemorySagaStorageLegacy()
+
+
+@pytest.fixture
+def saga_with_memory_storage() -> Saga[OrderContext]:
+    """
+    Create an OrderSaga configured with reserve-inventory, process-payment, and ship-order steps.
+
+    Returns a Saga subclass instance with the three ordered step handlers: ReserveInventoryStep, ProcessPaymentStep, and ShipOrderStep. No fixture dependencies.
+    """
+
+    class OrderSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep, ProcessPaymentStep, ShipOrderStep]
+
+    return OrderSaga()
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_memory_run_full_transaction(
+    benchmark,
+    saga_with_memory_storage: Saga[OrderContext],
+    saga_container: SagaContainer,
+    memory_storage: MemorySagaStorage,
+):
+    """Benchmark full saga transaction with memory storage, scoped run (3 steps)."""
+
+    async def run() -> None:
+        """
+        Execute a full saga transaction using the module's memory-backed saga, advancing through every step.
+
+        Creates an OrderContext with order_id "ord_1", user_id "user_1", and amount 100.0, opens a transaction using the provided saga container and memory storage, and iterates the transaction to exercise each step in the run path.
+        """
+        context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+        async with saga_with_memory_storage.transaction(
+            context=context,
+            container=saga_container,
+            storage=memory_storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_memory_run_single_step(
+    benchmark,
+    saga_with_memory_storage: Saga[OrderContext],
+    saga_container: SagaContainer,
+    memory_storage: MemorySagaStorage,
+):
+    """Benchmark saga with single step, scoped run (memory storage)."""
+
+    class SingleStepSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep]
+
+    saga = SingleStepSaga()
+
+    async def run() -> None:
+        context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+        async with saga.transaction(
+            context=context,
+            container=saga_container,
+            storage=memory_storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_memory_run_ten_transactions(
+    benchmark,
+    saga_with_memory_storage: Saga[OrderContext],
+    saga_container: SagaContainer,
+):
+    """Benchmark 10 saga transactions in sequence, scoped run (memory storage)."""
+
+    async def run() -> None:
+        """
+        Execute 10 sequential saga transactions using a fresh in-memory storage and context for each iteration.
+
+        Each iteration creates a new MemorySagaStorage and OrderContext, opens a saga transaction with the provided container and storage, and iterates through the transaction steps without performing additional work.
+        """
+        for i in range(10):
+            storage = MemorySagaStorage()
+            context = OrderContext(
+                order_id=f"ord_{i}",
+                user_id=f"user_{i}",
+                amount=100.0 + i,
+            )
+            async with saga_with_memory_storage.transaction(
+                context=context,
+                container=saga_container,
+                storage=storage,
+            ) as transaction:
+                async for _ in transaction:
+                    pass
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+# ---- Legacy path (no create_run, commit per storage call) ----
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_memory_legacy_full_transaction(
+    benchmark,
+    saga_with_memory_storage: Saga[OrderContext],
+    saga_container: SagaContainer,
+    memory_storage_legacy: MemorySagaStorageLegacy,
+):
+    """Benchmark full saga transaction with memory storage, legacy path (3 steps)."""
+
+    async def run() -> None:
+        """
+        Run a full-order saga transaction against the legacy in-memory storage used for benchmarks.
+
+        Creates an OrderContext and executes the saga transaction using the provided saga container and legacy memory storage, iterating the transaction to completion.
+        """
+        context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+        async with saga_with_memory_storage.transaction(
+            context=context,
+            container=saga_container,
+            storage=memory_storage_legacy,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_memory_legacy_single_step(
+    benchmark,
+    saga_with_memory_storage: Saga[OrderContext],
+    saga_container: SagaContainer,
+    memory_storage_legacy: MemorySagaStorageLegacy,
+):
+    """Benchmark saga with single step, legacy path (memory storage)."""
+
+    class SingleStepSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep]
+
+    saga = SingleStepSaga()
+
+    async def run() -> None:
+        """
+        Run a saga transaction using the legacy memory storage and iterate its steps.
+
+        Enters a transaction for an OrderContext (order_id "ord_1") with the registered saga_container and memory_storage_legacy, then iterates through the transaction steps without performing work for each step.
+        """
+        context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+        async with saga.transaction(
+            context=context,
+            container=saga_container,
+            storage=memory_storage_legacy,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_memory_legacy_ten_transactions(
+    benchmark,
+    saga_with_memory_storage: Saga[OrderContext],
+    saga_container: SagaContainer,
+):
+    """Benchmark 10 saga transactions in sequence, legacy path (memory storage)."""
+
+    async def run() -> None:
+        """
+        Execute ten sequential saga transactions using MemorySagaStorageLegacy.
+
+        Each iteration creates a new MemorySagaStorageLegacy and an OrderContext (with distinct order_id, user_id, and amount) and runs the configured saga transaction to completion by iterating through its steps.
+        """
+        for i in range(10):
+            storage = MemorySagaStorageLegacy()
+            context = OrderContext(
+                order_id=f"ord_{i}",
+                user_id=f"user_{i}",
+                amount=100.0 + i,
+            )
+            async with saga_with_memory_storage.transaction(
+                context=context,
+                container=saga_container,
+                storage=storage,
+            ) as transaction:
+                async for _ in transaction:
+                    pass
+
+    benchmark(lambda: asyncio.run(run()))
diff --git a/tests/benchmarks/dataclasses/test_benchmark_saga_sqlalchemy.py b/tests/benchmarks/dataclasses/test_benchmark_saga_sqlalchemy.py
new file mode 100644
index 0000000..d189588
--- /dev/null
+++ b/tests/benchmarks/dataclasses/test_benchmark_saga_sqlalchemy.py
@@ -0,0 +1,201 @@
+"""Benchmarks for Saga with SQLAlchemy storage (dataclass DCResponse). Requires DATABASE_DSN.
+
+- Benchmarks named *_run_* use the scoped run path (create_run, checkpoint commits).
+- Benchmarks named *_legacy_* use the legacy path (no create_run, commit per storage call).
+"""
+
+import pytest
+from sqlalchemy.ext.asyncio import async_sessionmaker
+
+from cqrs.saga.saga import Saga
+from cqrs.saga.storage.sqlalchemy import SqlAlchemySagaStorage
+
+from ..conftest import SqlAlchemySagaStorageLegacy
+from .test_benchmark_saga_memory import (
+    OrderContext,
+    ProcessPaymentStep,
+    ReserveInventoryStep,
+    SagaContainer,
+    ShipOrderStep,
+)
+
+
+@pytest.fixture
+def saga_container() -> SagaContainer:
+    """
+    Create and return a SagaContainer pre-registered with the ReserveInventoryStep, ProcessPaymentStep, and ShipOrderStep instances.
+
+    Returns:
+        SagaContainer: A container with the three steps already registered.
+    """
+    container = SagaContainer()
+    container.register(ReserveInventoryStep, ReserveInventoryStep())
+    container.register(ProcessPaymentStep, ProcessPaymentStep())
+    container.register(ShipOrderStep, ShipOrderStep())
+    return container
+
+
+@pytest.fixture
+def saga_sqlalchemy(saga_container: SagaContainer) -> Saga[OrderContext]:
+    class OrderSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep, ProcessPaymentStep, ShipOrderStep]
+
+    return OrderSaga()
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_sqlalchemy_run_full_transaction(
+    benchmark,
+    saga_sqlalchemy: Saga[OrderContext],
+    saga_container: SagaContainer,
+    saga_benchmark_loop_and_engine,
+):
+    """Benchmark full saga transaction with SQLAlchemy storage, scoped run (MySQL)."""
+    loop, engine = saga_benchmark_loop_and_engine
+
+    session_factory = async_sessionmaker(
+        engine,
+        expire_on_commit=False,
+        autocommit=False,
+        autoflush=False,
+    )
+    storage = SqlAlchemySagaStorage(session_factory)
+    context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+
+    async def run_transaction() -> None:
+        async with saga_sqlalchemy.transaction(
+            context=context,
+            container=saga_container,
+            storage=storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: loop.run_until_complete(run_transaction()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_sqlalchemy_run_single_step(
+    benchmark,
+    saga_container: SagaContainer,
+    saga_benchmark_loop_and_engine,
+):
+    """Benchmark saga with single step, scoped run (SQLAlchemy storage)."""
+    loop, engine = saga_benchmark_loop_and_engine
+
+    class SingleStepSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep]
+
+    saga = SingleStepSaga()
+
+    session_factory = async_sessionmaker(
+        engine,
+        expire_on_commit=False,
+        autocommit=False,
+        autoflush=False,
+    )
+    storage = SqlAlchemySagaStorage(session_factory)
+    context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+
+    async def run_transaction() -> None:
+        """
+        Execute the saga transaction lifecycle by entering the saga's transaction context and iterating its steps to completion.
+
+        This function opens the saga transaction using the surrounding `saga`, `saga_container`, `storage`, and `context`, then consumes the transaction iterator to drive all saga steps to completion.
+        """
+        async with saga.transaction(
+            context=context,
+            container=saga_container,
+            storage=storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: loop.run_until_complete(run_transaction()))
+
+
+# ---- Legacy path (no create_run, commit per storage call) ----
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_sqlalchemy_legacy_full_transaction(
+    benchmark,
+    saga_sqlalchemy: Saga[OrderContext],
+    saga_container: SagaContainer,
+    saga_benchmark_loop_and_engine,
+):
+    """
+    Benchmark a full saga transaction using SQLAlchemy storage in legacy mode.
+
+    Runs a complete saga (three-step OrderSaga) against SqlAlchemySagaStorageLegacy, which disables `create_run` so the storage exercises the legacy commit-per-call path. The benchmark executes the saga transaction in the provided event loop and database engine fixture.
+    """
+    loop, engine = saga_benchmark_loop_and_engine
+
+    session_factory = async_sessionmaker(
+        engine,
+        expire_on_commit=False,
+        autocommit=False,
+        autoflush=False,
+    )
+    storage = SqlAlchemySagaStorageLegacy(session_factory)
+    context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+
+    async def run_transaction() -> None:
+        """
+        Execute the configured saga transaction and iterate through all its steps to completion.
+
+        This coroutine opens a transaction using the surrounding `saga_sqlalchemy`, `saga_container`, `context`, and `storage` variables and consumes the transaction iterator without performing additional actions.
+        """
+        async with saga_sqlalchemy.transaction(
+            context=context,
+            container=saga_container,
+            storage=storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: loop.run_until_complete(run_transaction()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_sqlalchemy_legacy_single_step(
+    benchmark,
+    saga_container: SagaContainer,
+    saga_benchmark_loop_and_engine,
+):
+    """
+    Benchmark executing a single-step Saga using legacy SQLAlchemy storage (commit-per-call path).
+
+    Constructs a SingleStepSaga with ReserveInventoryStep, creates a SqlAlchemySagaStorageLegacy backed by the provided engine/session factory, and measures running a full saga transaction (iterating the transaction to completion) using the provided event loop via the benchmark fixture.
+    """
+    loop, engine = saga_benchmark_loop_and_engine
+
+    class SingleStepSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep]
+
+    saga = SingleStepSaga()
+
+    session_factory = async_sessionmaker(
+        engine,
+        expire_on_commit=False,
+        autocommit=False,
+        autoflush=False,
+    )
+    storage = SqlAlchemySagaStorageLegacy(session_factory)
+    context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+
+    async def run_transaction() -> None:
+        """
+        Execute the saga transaction lifecycle by entering the saga's transaction context and iterating its steps to completion.
+
+        This function opens the saga transaction using the surrounding `saga`, `saga_container`, `storage`, and `context`, then consumes the transaction iterator to drive all saga steps to completion.
+        """
+        async with saga.transaction(
+            context=context,
+            container=saga_container,
+            storage=storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: loop.run_until_complete(run_transaction()))
diff --git a/tests/benchmarks/dataclasses/test_benchmark_serialization.py b/tests/benchmarks/dataclasses/test_benchmark_serialization.py
new file mode 100644
index 0000000..4e2fbd4
--- /dev/null
+++ b/tests/benchmarks/dataclasses/test_benchmark_serialization.py
@@ -0,0 +1,88 @@
+"""Benchmarks for serialization and deserialization (dataclass DCRequest/DCResponse)."""
+
+import dataclasses
+
+import cqrs
+import pytest
+
+
+@dataclasses.dataclass
+class SampleRequest(cqrs.DCRequest):
+    field1: str
+    field2: int
+    field3: list[str]
+    field4: dict[str, int]
+
+
+@dataclasses.dataclass
+class SampleResponse(cqrs.DCResponse):
+    result: str
+    data: dict[str, str]
+
+
+@pytest.mark.benchmark
+def test_benchmark_request_to_dict(benchmark):
+    """Benchmark request serialization to dictionary."""
+    request = SampleRequest(
+        field1="test_value",
+        field2=42,
+        field3=["a", "b", "c"],
+        field4={"key1": 1, "key2": 2},
+    )
+
+    benchmark(lambda: request.to_dict())
+
+
+@pytest.mark.benchmark
+def test_benchmark_request_from_dict(benchmark):
+    """Benchmark request deserialization from dictionary."""
+    data = {
+        "field1": "test_value",
+        "field2": 42,
+        "field3": ["a", "b", "c"],
+        "field4": {"key1": 1, "key2": 2},
+    }
+
+    benchmark(lambda: SampleRequest.from_dict(**data))
+
+
+@pytest.mark.benchmark
+def test_benchmark_response_to_dict(benchmark):
+    """Benchmark response serialization to dictionary."""
+    response = SampleResponse(
+        result="success",
+        data={"key1": "value1", "key2": "value2"},
+    )
+
+    benchmark(lambda: response.to_dict())
+
+
+@pytest.mark.benchmark
+def test_benchmark_response_from_dict(benchmark):
+    """Benchmark response deserialization from dictionary."""
+    data = {
+        "result": "success",
+        "data": {"key1": "value1", "key2": "value2"},
+    }
+
+    benchmark(lambda: SampleResponse.from_dict(**data))
+
+
+@pytest.mark.benchmark
+def test_benchmark_complex_nested_structure(benchmark):
+    """Benchmark serialization of complex nested structures."""
+
+    @dataclasses.dataclass
+    class NestedRequest(cqrs.DCRequest):
+        level1: dict[str, list[dict[str, str]]]
+        level2: list[dict[str, int]]
+
+    request = NestedRequest(
+        level1={
+            "group1": [{"name": "item1", "value": "val1"}] * 5,
+            "group2": [{"name": "item2", "value": "val2"}] * 5,
+        },
+        level2=[{"counter": i} for i in range(10)],
+    )
+
+    benchmark(lambda: request.to_dict())
diff --git a/tests/benchmarks/dataclasses/test_benchmark_stream_request_handler.py b/tests/benchmarks/dataclasses/test_benchmark_stream_request_handler.py
new file mode 100644
index 0000000..8bd73ac
--- /dev/null
+++ b/tests/benchmarks/dataclasses/test_benchmark_stream_request_handler.py
@@ -0,0 +1,122 @@
+"""Benchmarks for StreamingRequestHandler (dataclass DCRequest/DCResponse)."""
+
+import asyncio
+import dataclasses
+import typing
+
+import cqrs
+import di
+import pytest
+from cqrs.events.event import IEvent
+from cqrs.requests import bootstrap
+from cqrs.requests.request_handler import StreamingRequestHandler
+from cqrs.response import DCResponse
+
+
+@dataclasses.dataclass
+class ProcessItemsCommand(cqrs.DCRequest):
+    item_ids: list[str]
+
+
+@dataclasses.dataclass
+class ProcessItemResult(DCResponse):
+    item_id: str
+    status: str
+
+
+class StreamingHandler(StreamingRequestHandler[ProcessItemsCommand, ProcessItemResult]):
+    def __init__(self) -> None:
+        self._events: list[IEvent] = []
+
+    @property
+    def events(self) -> typing.Sequence[IEvent]:
+        return self._events.copy()
+
+    def clear_events(self) -> None:
+        self._events.clear()
+
+    async def handle(
+        self,
+        request: ProcessItemsCommand,
+    ) -> typing.AsyncIterator[ProcessItemResult]:
+        for item_id in request.item_ids:
+            self._events.append(
+                cqrs.NotificationEvent(
+                    event_name="ItemProcessed",
+                    payload={"item_id": item_id},
+                ),
+            )
+            yield ProcessItemResult(item_id=item_id, status="processed")
+
+
+def streaming_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(ProcessItemsCommand, StreamingHandler)
+
+
+@pytest.fixture
+def streaming_mediator():
+    return bootstrap.bootstrap_streaming(
+        di_container=di.Container(),
+        commands_mapper=streaming_mapper,
+    )
+
+
+@pytest.mark.benchmark
+def test_benchmark_stream_single_item(streaming_mediator, benchmark):
+    """Benchmark streaming handler with single item."""
+
+    async def run():
+        request = ProcessItemsCommand(item_ids=["item_1"])
+        results = []
+        async for result in streaming_mediator.stream(request):
+            results.append(result)
+        return results
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_stream_ten_items(streaming_mediator, benchmark):
+    """Benchmark streaming handler with 10 items."""
+
+    async def run():
+        request = ProcessItemsCommand(
+            item_ids=[f"item_{i}" for i in range(10)],
+        )
+        results = []
+        async for result in streaming_mediator.stream(request):
+            results.append(result)
+        return results
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_stream_hundred_items(streaming_mediator, benchmark):
+    """Benchmark streaming handler with 100 items."""
+
+    async def run():
+        request = ProcessItemsCommand(
+            item_ids=[f"item_{i}" for i in range(100)],
+        )
+        results = []
+        async for result in streaming_mediator.stream(request):
+            results.append(result)
+        return results
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_stream_ten_requests_five_items_each(streaming_mediator, benchmark):
+    """Benchmark 10 streaming requests with 5 items each."""
+
+    async def run():
+        for i in range(10):
+            request = ProcessItemsCommand(
+                item_ids=[f"item_{i}_{j}" for j in range(5)],
+            )
+            async for _ in streaming_mediator.stream(request):
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
diff --git a/tests/benchmarks/default/__init__.py b/tests/benchmarks/default/__init__.py
new file mode 100644
index 0000000..284ca51
--- /dev/null
+++ b/tests/benchmarks/default/__init__.py
@@ -0,0 +1 @@
+"""Default benchmarks (Request, Response, Event — current default implementation)."""
diff --git a/tests/benchmarks/default/test_benchmark_cor_request_handler.py b/tests/benchmarks/default/test_benchmark_cor_request_handler.py
new file mode 100644
index 0000000..08963be
--- /dev/null
+++ b/tests/benchmarks/default/test_benchmark_cor_request_handler.py
@@ -0,0 +1,145 @@
+"""Benchmarks for Chain of Responsibility (default Request/Response)."""
+
+import asyncio
+import typing
+
+import cqrs
+import di
+import pytest
+from cqrs.requests import bootstrap
+from cqrs.requests.cor_request_handler import CORRequestHandler
+
+
+class TRequest(cqrs.Request):
+    method: str
+    user_id: str
+
+
+class TResult(cqrs.Response):
+    success: bool
+    handler_name: str
+    message: str = ""
+
+
+class HandlerA(CORRequestHandler[TRequest, TResult | None]):
+    @property
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
+        return []
+
+    async def handle(self, request: TRequest) -> TResult | None:
+        if request.method == "method_a":
+            return TResult(
+                success=True,
+                handler_name="HandlerA",
+                message=f"Processed method_a for {request.user_id}",
+            )
+        return await self.next(request)
+
+
+class HandlerB(CORRequestHandler[TRequest, TResult | None]):
+    @property
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
+        return []
+
+    async def handle(self, request: TRequest) -> TResult | None:
+        if request.method == "method_b":
+            return TResult(
+                success=True,
+                handler_name="HandlerB",
+                message=f"Processed method_b for {request.user_id}",
+            )
+        return await self.next(request)
+
+
+class HandlerC(CORRequestHandler[TRequest, TResult | None]):
+    @property
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
+        return []
+
+    async def handle(self, request: TRequest) -> TResult | None:
+        if request.method == "method_c":
+            return TResult(
+                success=True,
+                handler_name="HandlerC",
+                message=f"Processed method_c for {request.user_id}",
+            )
+        return await self.next(request)
+
+
+class DefaultHandler(CORRequestHandler[TRequest, TResult | None]):
+    @property
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
+        return []
+
+    async def handle(self, request: TRequest) -> TResult | None:
+        return TResult(
+            success=False,
+            handler_name="DefaultHandler",
+            message=f"Unsupported method: {request.method}",
+        )
+
+
+def cor_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(
+        TRequest,
+        [HandlerA, HandlerB, HandlerC, DefaultHandler],
+    )
+
+
+@pytest.fixture
+def cor_mediator():
+    return bootstrap.bootstrap(
+        di_container=di.Container(),
+        commands_mapper=cor_mapper,
+    )
+
+
+@pytest.mark.benchmark
+def test_benchmark_cor_first_handler(cor_mediator, benchmark):
+    """Benchmark CoR when first handler in chain handles the request."""
+
+    async def run():
+        return await cor_mediator.send(TRequest(method="method_a", user_id="user_1"))
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_cor_second_handler(cor_mediator, benchmark):
+    """Benchmark CoR when second handler in chain handles the request."""
+
+    async def run():
+        return await cor_mediator.send(TRequest(method="method_b", user_id="user_1"))
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_cor_third_handler(cor_mediator, benchmark):
+    """Benchmark CoR when third handler in chain handles the request."""
+
+    async def run():
+        return await cor_mediator.send(TRequest(method="method_c", user_id="user_1"))
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_cor_default_handler(cor_mediator, benchmark):
+    """Benchmark CoR when only default (last) handler handles the request."""
+
+    async def run():
+        return await cor_mediator.send(TRequest(method="other", user_id="user_1"))
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_cor_ten_requests_first_handler(cor_mediator, benchmark):
+    """Benchmark CoR handling 10 requests (first handler)."""
+
+    async def run():
+        for i in range(10):
+            await cor_mediator.send(TRequest(method="method_a", user_id=f"user_{i}"))
+
+    benchmark(lambda: asyncio.run(run()))
diff --git a/tests/benchmarks/default/test_benchmark_event_handler_chain.py b/tests/benchmarks/default/test_benchmark_event_handler_chain.py
new file mode 100644
index 0000000..a335f54
--- /dev/null
+++ b/tests/benchmarks/default/test_benchmark_event_handler_chain.py
@@ -0,0 +1,140 @@
+"""Benchmarks: 3-level event chain, volume >> semaphore (parallel follow-ups)."""
+
+import asyncio
+
+import pydantic
+import pytest
+
+from cqrs.events import DomainEvent, EventEmitter, EventHandler, EventMap
+from cqrs.events.event import IEvent
+from cqrs.events.event_processor import EventProcessor
+from cqrs.container.protocol import Container
+
+
+class _EventL1(DomainEvent, frozen=True):
+    id_: str = pydantic.Field(alias="id")
+    model_config = pydantic.ConfigDict(populate_by_name=True)
+
+
+class _EventL2(DomainEvent, frozen=True):
+    id_: str = pydantic.Field(alias="id")
+    model_config = pydantic.ConfigDict(populate_by_name=True)
+
+
+class _EventL3(DomainEvent, frozen=True):
+    id_: str = pydantic.Field(alias="id")
+    model_config = pydantic.ConfigDict(populate_by_name=True)
+
+
+# Number of follow-ups per level so total events >> semaphore
+FAN_OUT_L1 = 10
+FAN_OUT_L2 = 5
+SEMAPHORE_SIZE = 4
+
+
+class _HandlerL1(EventHandler[_EventL1]):
+    def __init__(self) -> None:
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> tuple[IEvent, ...]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: _EventL1) -> None:
+        self._follow_ups = [_EventL2(id=f"l2_{event.id_}_{i}") for i in range(FAN_OUT_L1)]
+
+
+class _HandlerL2(EventHandler[_EventL2]):
+    def __init__(self) -> None:
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> tuple[IEvent, ...]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: _EventL2) -> None:
+        self._follow_ups = [_EventL3(id=f"l3_{event.id_}_{i}") for i in range(FAN_OUT_L2)]
+
+
+class _HandlerL3(EventHandler[_EventL3]):
+    async def handle(self, event: _EventL3) -> None:
+        pass
+
+
+class _ChainContainer(Container[object]):
+    def __init__(self) -> None:
+        self._h1 = _HandlerL1()
+        self._h2 = _HandlerL2()
+        self._h3 = _HandlerL3()
+        self._external: object | None = None
+
+    @property
+    def external_container(self) -> object:
+        return self._external  # type: ignore[return-value]
+
+    def attach_external_container(self, container: object) -> None:
+        self._external = container
+
+    async def resolve(self, type_: type) -> EventHandler[IEvent]:
+        if type_ is _HandlerL1:
+            return self._h1  # type: ignore[return-value]
+        if type_ is _HandlerL2:
+            return self._h2  # type: ignore[return-value]
+        if type_ is _HandlerL3:
+            return self._h3  # type: ignore[return-value]
+        raise KeyError(type_)
+
+
+def _make_processor(parallel: bool) -> EventProcessor:
+    event_map = EventMap()
+    event_map.bind(_EventL1, _HandlerL1)
+    event_map.bind(_EventL2, _HandlerL2)
+    event_map.bind(_EventL3, _HandlerL3)
+    container = _ChainContainer()
+    emitter = EventEmitter(event_map=event_map, container=container)
+    return EventProcessor(
+        event_map=event_map,
+        event_emitter=emitter,
+        max_concurrent_event_handlers=SEMAPHORE_SIZE,
+        concurrent_event_handle_enable=parallel,
+    )
+
+
+@pytest.fixture
+def event_processor_chain_parallel() -> EventProcessor:
+    """EventProcessor with 3-level chain, parallel, semaphore=4."""
+    return _make_processor(parallel=True)
+
+
+@pytest.mark.benchmark
+def test_benchmark_event_chain_three_levels_parallel(
+    benchmark,
+    event_processor_chain_parallel: EventProcessor,
+) -> None:
+    """Benchmark: 1 root event -> 10 L2 -> 50 L3 (61 total), semaphore 4."""
+    processor = event_processor_chain_parallel
+
+    async def run() -> None:
+        await processor.emit_events([_EventL1(id="root")])
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.fixture
+def event_processor_chain_sequential() -> EventProcessor:
+    """EventProcessor with 3-level chain, sequential."""
+    return _make_processor(parallel=False)
+
+
+@pytest.mark.benchmark
+def test_benchmark_event_chain_three_levels_sequential(
+    benchmark,
+    event_processor_chain_sequential: EventProcessor,
+) -> None:
+    """Benchmark: same 3-level chain, sequential (BFS)."""
+    processor = event_processor_chain_sequential
+
+    async def run() -> None:
+        await processor.emit_events([_EventL1(id="root")])
+
+    benchmark(lambda: asyncio.run(run()))
diff --git a/tests/benchmarks/default/test_benchmark_event_handling.py b/tests/benchmarks/default/test_benchmark_event_handling.py
new file mode 100644
index 0000000..5611678
--- /dev/null
+++ b/tests/benchmarks/default/test_benchmark_event_handling.py
@@ -0,0 +1,73 @@
+"""Benchmarks for event handling performance (default Event)."""
+
+import asyncio
+import typing
+
+import di
+import pytest
+
+import cqrs
+from cqrs.events import bootstrap
+
+
+class UserJoinedEvent(cqrs.Event, frozen=True):
+    user_id: str
+    meeting_id: str
+
+
+class UserJoinedEventHandler(cqrs.EventHandler[UserJoinedEvent]):
+    def __init__(self):
+        self.processed_events: typing.List[UserJoinedEvent] = []
+
+    async def handle(self, event: UserJoinedEvent) -> None:
+        self.processed_events.append(event)
+
+
+def events_mapper(mapper: cqrs.EventMap) -> None:
+    mapper.bind(UserJoinedEvent, UserJoinedEventHandler)
+
+
+@pytest.fixture
+def event_mediator():
+    return bootstrap.bootstrap(
+        di_container=di.Container(),
+        events_mapper=events_mapper,
+    )
+
+
+@pytest.mark.benchmark
+def test_benchmark_event_processing(benchmark, event_mediator):
+    """Benchmark event processing performance."""
+    event = UserJoinedEvent(user_id="user_1", meeting_id="meeting_1")
+
+    async def run():
+        await event_mediator.send(event)
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_multiple_events(benchmark, event_mediator):
+    """Benchmark processing multiple events in sequence."""
+    events = [UserJoinedEvent(user_id=f"user_{i}", meeting_id="meeting_1") for i in range(10)]
+
+    async def run():
+        for evt in events:
+            await event_mediator.send(evt)
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_notification_event(benchmark):
+    """Benchmark notification event creation and serialization."""
+
+    def run():
+        event = cqrs.NotificationEvent[UserJoinedEvent](
+            event_name="UserJoined",
+            topic="test_topic",
+            payload=UserJoinedEvent(user_id="user_1", meeting_id="meeting_1"),
+        )
+        return event.to_dict()
+
+    benchmark(run)
diff --git a/tests/benchmarks/default/test_benchmark_request_handling.py b/tests/benchmarks/default/test_benchmark_request_handling.py
new file mode 100644
index 0000000..571df41
--- /dev/null
+++ b/tests/benchmarks/default/test_benchmark_request_handling.py
@@ -0,0 +1,100 @@
+"""Benchmarks for request handling performance (default Request/Response)."""
+
+import asyncio
+import typing
+from collections import defaultdict
+
+import cqrs
+import di
+import pytest
+from cqrs.requests import bootstrap
+
+STORAGE = defaultdict[str, typing.List[str]](lambda: [])
+
+
+class JoinMeetingCommand(cqrs.Request):
+    user_id: str
+    meeting_id: str
+
+
+class ReadMeetingQuery(cqrs.Request):
+    meeting_id: str
+
+
+class ReadMeetingQueryResult(cqrs.Response):
+    users: list[str]
+
+
+class JoinMeetingCommandHandler(cqrs.RequestHandler[JoinMeetingCommand, None]):
+    @property
+    def events(self):
+        return []
+
+    async def handle(self, request: JoinMeetingCommand) -> None:
+        STORAGE[request.meeting_id].append(request.user_id)
+
+
+class ReadMeetingQueryHandler(
+    cqrs.RequestHandler[ReadMeetingQuery, ReadMeetingQueryResult],
+):
+    @property
+    def events(self):
+        return []
+
+    async def handle(self, request: ReadMeetingQuery) -> ReadMeetingQueryResult:
+        return ReadMeetingQueryResult(users=STORAGE[request.meeting_id])
+
+
+def command_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(JoinMeetingCommand, JoinMeetingCommandHandler)
+
+
+def query_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(ReadMeetingQuery, ReadMeetingQueryHandler)
+
+
+@pytest.fixture
+def mediator():
+    return bootstrap.bootstrap(
+        di_container=di.Container(),
+        queries_mapper=query_mapper,
+        commands_mapper=command_mapper,
+    )
+
+
+@pytest.mark.benchmark
+def test_benchmark_command_handling(benchmark, mediator):
+    """Benchmark command handling performance."""
+    STORAGE.clear()
+    command = JoinMeetingCommand(user_id="user_1", meeting_id="meeting_1")
+
+    async def run():
+        await mediator.send(command)
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_query_handling(benchmark, mediator):
+    """Benchmark query handling performance."""
+    STORAGE.clear()
+    STORAGE["meeting_1"] = ["user_1", "user_2", "user_3"]
+    query = ReadMeetingQuery(meeting_id="meeting_1")
+
+    async def run():
+        return await mediator.send(query)
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_multiple_commands(benchmark, mediator):
+    """Benchmark handling multiple commands in sequence."""
+    STORAGE.clear()
+    commands = [JoinMeetingCommand(user_id=f"user_{i}", meeting_id="meeting_2") for i in range(10)]
+
+    async def run():
+        for cmd in commands:
+            await mediator.send(cmd)
+
+    benchmark(lambda: asyncio.run(run()))
diff --git a/tests/benchmarks/default/test_benchmark_saga_fallback.py b/tests/benchmarks/default/test_benchmark_saga_fallback.py
new file mode 100644
index 0000000..7267b56
--- /dev/null
+++ b/tests/benchmarks/default/test_benchmark_saga_fallback.py
@@ -0,0 +1,129 @@
+"""Benchmarks for Saga with Fallback (default Response)."""
+
+import asyncio
+
+import pytest
+from cqrs.adapters.circuit_breaker import AioBreakerAdapter
+from cqrs.events.event import Event
+from cqrs.saga.fallback import Fallback
+from cqrs.saga.saga import Saga
+from cqrs.saga.step import SagaStepHandler, SagaStepResult
+from cqrs.saga.storage.memory import MemorySagaStorage
+
+from .test_benchmark_saga_memory import (
+    OrderContext,
+    ProcessPaymentStep,
+    ReserveInventoryResponse,
+    ReserveInventoryStep,
+    SagaContainer,
+    ShipOrderStep,
+)
+
+
+class FallbackReserveStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+    """Fallback step used when primary fails (not used in happy-path benchmark)."""
+
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        response = ReserveInventoryResponse(
+            inventory_id=f"fallback_inv_{context.order_id}",
+            reserved=True,
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        pass
+
+
+@pytest.fixture
+def saga_container_fallback() -> SagaContainer:
+    container = SagaContainer()
+    container.register(ReserveInventoryStep, ReserveInventoryStep())
+    container.register(FallbackReserveStep, FallbackReserveStep())
+    container.register(ProcessPaymentStep, ProcessPaymentStep())
+    container.register(ShipOrderStep, ShipOrderStep())
+    return container
+
+
+@pytest.fixture
+def memory_storage() -> MemorySagaStorage:
+    return MemorySagaStorage()
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_fallback_without_circuit_breaker(
+    benchmark,
+    saga_container_fallback: SagaContainer,
+    memory_storage: MemorySagaStorage,
+):
+    """Benchmark saga with Fallback step (no circuit breaker). Primary step runs."""
+
+    class SagaWithFallbackNoCB(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=ReserveInventoryStep,
+                fallback=FallbackReserveStep,
+                circuit_breaker=None,
+            ),
+            ProcessPaymentStep,
+            ShipOrderStep,
+        ]
+
+    saga = SagaWithFallbackNoCB()
+
+    async def run() -> None:
+        context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+        async with saga.transaction(
+            context=context,
+            container=saga_container_fallback,
+            storage=memory_storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_fallback_with_aiobreaker_adapter(
+    benchmark,
+    saga_container_fallback: SagaContainer,
+    memory_storage: MemorySagaStorage,
+):
+    """Benchmark saga with Fallback step and AioBreakerAdapter circuit breaker."""
+
+    circuit_breaker = AioBreakerAdapter(fail_max=5, timeout_duration=60)
+
+    class SagaWithFallbackWithCB(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=ReserveInventoryStep,
+                fallback=FallbackReserveStep,
+                circuit_breaker=circuit_breaker,
+            ),
+            ProcessPaymentStep,
+            ShipOrderStep,
+        ]
+
+    saga = SagaWithFallbackWithCB()
+
+    async def run() -> None:
+        context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+        async with saga.transaction(
+            context=context,
+            container=saga_container_fallback,
+            storage=memory_storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
diff --git a/tests/benchmarks/default/test_benchmark_saga_memory.py b/tests/benchmarks/default/test_benchmark_saga_memory.py
new file mode 100644
index 0000000..9c2aa96
--- /dev/null
+++ b/tests/benchmarks/default/test_benchmark_saga_memory.py
@@ -0,0 +1,359 @@
+"""Benchmarks for Saga with memory storage (default Response).
+
+- Benchmarks named *_run_* use the scoped run path (create_run, checkpoint commits).
+- Benchmarks named *_legacy_* use the legacy path (no create_run, commit per storage call).
+"""
+
+import asyncio
+import dataclasses
+import typing
+
+import pytest
+from cqrs.events.event import Event
+from cqrs.response import Response
+from cqrs.saga.models import SagaContext
+from cqrs.saga.saga import Saga
+from cqrs.saga.step import SagaStepHandler, SagaStepResult
+from cqrs.saga.storage.memory import MemorySagaStorage
+
+from ..conftest import MemorySagaStorageLegacy
+
+
+@dataclasses.dataclass
+class OrderContext(SagaContext):
+    order_id: str
+    user_id: str
+    amount: float
+
+
+class ReserveInventoryResponse(Response):
+    inventory_id: str
+    reserved: bool
+
+
+class ProcessPaymentResponse(Response):
+    payment_id: str
+    charged: bool
+
+
+class ShipOrderResponse(Response):
+    shipment_id: str
+    shipped: bool
+
+
+class ReserveInventoryStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        response = ReserveInventoryResponse(
+            inventory_id=f"inv_{context.order_id}",
+            reserved=True,
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        pass
+
+
+class ProcessPaymentStep(SagaStepHandler[OrderContext, ProcessPaymentResponse]):
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ProcessPaymentResponse]:
+        response = ProcessPaymentResponse(
+            payment_id=f"pay_{context.order_id}",
+            charged=True,
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        pass
+
+
+class ShipOrderStep(SagaStepHandler[OrderContext, ShipOrderResponse]):
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ShipOrderResponse]:
+        response = ShipOrderResponse(
+            shipment_id=f"ship_{context.order_id}",
+            shipped=True,
+        )
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        pass
+
+
+class SagaContainer:
+    """Simple container that resolves saga step handlers."""
+
+    def __init__(self) -> None:
+        self._handlers: dict[type, SagaStepHandler] = {}
+        self._external_container: typing.Any = None
+
+    def register(self, handler_type: type, handler: SagaStepHandler) -> None:
+        self._handlers[handler_type] = handler
+
+    @property
+    def external_container(self) -> typing.Any:
+        return self._external_container
+
+    def attach_external_container(self, container: typing.Any) -> None:
+        self._external_container = container
+
+    async def resolve(self, type_: type) -> typing.Any:
+        if type_ not in self._handlers:
+            self._handlers[type_] = type_()
+        return self._handlers[type_]
+
+
+@pytest.fixture
+def saga_container() -> SagaContainer:
+    container = SagaContainer()
+    container.register(ReserveInventoryStep, ReserveInventoryStep())
+    container.register(ProcessPaymentStep, ProcessPaymentStep())
+    container.register(ShipOrderStep, ShipOrderStep())
+    return container
+
+
+@pytest.fixture
+def memory_storage() -> MemorySagaStorage:
+    """
+    Create a fresh in-memory saga storage instance for tests.
+
+    Returns:
+        MemorySagaStorage: A new MemorySagaStorage used to persist saga state in memory.
+    """
+    return MemorySagaStorage()
+
+
+@pytest.fixture
+def memory_storage_legacy() -> MemorySagaStorageLegacy:
+    """
+    Create a MemorySagaStorageLegacy instance for legacy-path benchmarks.
+
+    Returns:
+        MemorySagaStorageLegacy: A storage instance where `create_run()` is disabled and will raise NotImplementedError if called.
+    """
+    return MemorySagaStorageLegacy()
+
+
+@pytest.fixture
+def saga_with_memory_storage() -> Saga[OrderContext]:
+    """
+    Create an OrderSaga preconfigured with inventory reservation, payment processing, and shipping steps.
+
+    Returns:
+        Saga[OrderContext]: An instance configured with ReserveInventoryStep, ProcessPaymentStep, and ShipOrderStep.
+    """
+
+    class OrderSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep, ProcessPaymentStep, ShipOrderStep]
+
+    return OrderSaga()
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_memory_run_full_transaction(
+    benchmark,
+    saga_with_memory_storage: Saga[OrderContext],
+    saga_container: SagaContainer,
+    memory_storage: MemorySagaStorage,
+):
+    """Benchmark full saga transaction with memory storage, scoped run (3 steps)."""
+
+    async def run() -> None:
+        """
+        Execute a full three-step OrderSaga transaction using the memory storage scoped-run path.
+
+        Creates an OrderContext and runs the saga transaction to completion with the provided saga container and memory storage.
+        """
+        context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+        async with saga_with_memory_storage.transaction(
+            context=context,
+            container=saga_container,
+            storage=memory_storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_memory_run_single_step(
+    benchmark,
+    saga_with_memory_storage: Saga[OrderContext],
+    saga_container: SagaContainer,
+    memory_storage: MemorySagaStorage,
+):
+    """Benchmark saga with single step, scoped run (memory storage)."""
+
+    class SingleStepSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep]
+
+    saga = SingleStepSaga()
+
+    async def run() -> None:
+        context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+        async with saga.transaction(
+            context=context,
+            container=saga_container,
+            storage=memory_storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_memory_run_ten_transactions(
+    benchmark,
+    saga_with_memory_storage: Saga[OrderContext],
+    saga_container: SagaContainer,
+):
+    """Benchmark 10 saga transactions in sequence, scoped run (memory storage)."""
+
+    async def run() -> None:
+        """
+        Run ten sequential saga transactions, each using a new MemorySagaStorage and an OrderContext.
+
+        Each iteration (i from 0 to 9) creates:
+        - a fresh MemorySagaStorage,
+        - an OrderContext with order_id "ord_i", user_id "user_i", and amount 100.0 + i,
+        then opens a transaction from `saga_with_memory_storage` with `saga_container` and the storage and iterates the transaction to completion.
+        """
+        for i in range(10):
+            storage = MemorySagaStorage()
+            context = OrderContext(
+                order_id=f"ord_{i}",
+                user_id=f"user_{i}",
+                amount=100.0 + i,
+            )
+            async with saga_with_memory_storage.transaction(
+                context=context,
+                container=saga_container,
+                storage=storage,
+            ) as transaction:
+                async for _ in transaction:
+                    pass
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+# ---- Legacy path (no create_run, commit per storage call) ----
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_memory_legacy_full_transaction(
+    benchmark,
+    saga_with_memory_storage: Saga[OrderContext],
+    saga_container: SagaContainer,
+    memory_storage_legacy: MemorySagaStorageLegacy,
+):
+    """Benchmark full saga transaction with memory storage, legacy path (3 steps)."""
+
+    async def run() -> None:
+        """
+        Execute a full OrderSaga transaction using the legacy memory storage path.
+
+        Builds an OrderContext (order_id "ord_1", user_id "user_1", amount 100.0) and runs the saga_with_memory_storage transaction with saga_container and memory_storage_legacy, iterating the transaction to completion.
+        """
+        context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+        async with saga_with_memory_storage.transaction(
+            context=context,
+            container=saga_container,
+            storage=memory_storage_legacy,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_memory_legacy_single_step(
+    benchmark,
+    saga_with_memory_storage: Saga[OrderContext],
+    saga_container: SagaContainer,
+    memory_storage_legacy: MemorySagaStorageLegacy,
+):
+    """Benchmark saga with single step, legacy path (memory storage)."""
+
+    class SingleStepSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep]
+
+    saga = SingleStepSaga()
+
+    async def run() -> None:
+        """
+        Runs a full OrderSaga transaction using the legacy memory storage path.
+
+        This coroutine executes the saga with an OrderContext and the MemorySagaStorageLegacy instance so the saga proceeds through all steps while exercising the legacy storage behavior (create_run disabled, commit-per-call path).
+        """
+        context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+        async with saga.transaction(
+            context=context,
+            container=saga_container,
+            storage=memory_storage_legacy,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_memory_legacy_ten_transactions(
+    benchmark,
+    saga_with_memory_storage: Saga[OrderContext],
+    saga_container: SagaContainer,
+):
+    """Benchmark 10 saga transactions in sequence, legacy path (memory storage)."""
+
+    async def run() -> None:
+        """
+        Run ten sequential saga transactions using the legacy memory storage path.
+
+        For each iteration this function creates a new MemorySagaStorageLegacy, constructs an OrderContext with a unique order_id and user_id and increasing amount, opens a saga transaction using the shared saga_with_memory_storage and saga_container, and iterates the transaction to completion.
+        """
+        for i in range(10):
+            storage = MemorySagaStorageLegacy()
+            context = OrderContext(
+                order_id=f"ord_{i}",
+                user_id=f"user_{i}",
+                amount=100.0 + i,
+            )
+            async with saga_with_memory_storage.transaction(
+                context=context,
+                container=saga_container,
+                storage=storage,
+            ) as transaction:
+                async for _ in transaction:
+                    pass
+
+    benchmark(lambda: asyncio.run(run()))
diff --git a/tests/benchmarks/default/test_benchmark_saga_sqlalchemy.py b/tests/benchmarks/default/test_benchmark_saga_sqlalchemy.py
new file mode 100644
index 0000000..7a82ccf
--- /dev/null
+++ b/tests/benchmarks/default/test_benchmark_saga_sqlalchemy.py
@@ -0,0 +1,192 @@
+"""Benchmarks for Saga with SQLAlchemy storage (default Response). Requires DATABASE_DSN.
+
+- Benchmarks named *_run_* use the scoped run path (create_run, checkpoint commits).
+- Benchmarks named *_legacy_* use the legacy path (no create_run, commit per storage call).
+"""
+
+import pytest
+from sqlalchemy.ext.asyncio import async_sessionmaker
+
+from cqrs.saga.saga import Saga
+from cqrs.saga.storage.sqlalchemy import SqlAlchemySagaStorage
+
+from ..conftest import SqlAlchemySagaStorageLegacy
+from .test_benchmark_saga_memory import (
+    OrderContext,
+    ProcessPaymentStep,
+    ReserveInventoryStep,
+    SagaContainer,
+    ShipOrderStep,
+)
+
+
+def _make_storage(engine, storage_cls):
+    """Build saga storage from engine and storage class (shared by legacy benchmarks)."""
+    session_factory = async_sessionmaker(
+        engine,
+        expire_on_commit=False,
+        autocommit=False,
+        autoflush=False,
+    )
+    return storage_cls(session_factory)
+
+
+@pytest.fixture
+def saga_container() -> SagaContainer:
+    """
+    Create a SagaContainer pre-registered with the standard order saga steps.
+
+    Returns:
+        SagaContainer: Container with ReserveInventoryStep, ProcessPaymentStep, and ShipOrderStep registered.
+    """
+    container = SagaContainer()
+    container.register(ReserveInventoryStep, ReserveInventoryStep())
+    container.register(ProcessPaymentStep, ProcessPaymentStep())
+    container.register(ShipOrderStep, ShipOrderStep())
+    return container
+
+
+@pytest.fixture
+def saga_sqlalchemy(saga_container: SagaContainer) -> Saga[OrderContext]:
+    class OrderSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep, ProcessPaymentStep, ShipOrderStep]
+
+    return OrderSaga()
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_sqlalchemy_run_full_transaction(
+    benchmark,
+    saga_sqlalchemy: Saga[OrderContext],
+    saga_container: SagaContainer,
+    saga_benchmark_loop_and_engine,
+):
+    """Benchmark full saga transaction with SQLAlchemy storage, scoped run (MySQL)."""
+    loop, engine = saga_benchmark_loop_and_engine
+
+    session_factory = async_sessionmaker(
+        engine,
+        expire_on_commit=False,
+        autocommit=False,
+        autoflush=False,
+    )
+    storage = SqlAlchemySagaStorage(session_factory)
+    context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+
+    async def run_transaction() -> None:
+        async with saga_sqlalchemy.transaction(
+            context=context,
+            container=saga_container,
+            storage=storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: loop.run_until_complete(run_transaction()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_saga_sqlalchemy_run_single_step(
+    benchmark,
+    saga_container: SagaContainer,
+    saga_benchmark_loop_and_engine,
+):
+    """Benchmark saga with single step, scoped run (SQLAlchemy storage)."""
+    loop, engine = saga_benchmark_loop_and_engine
+
+    class SingleStepSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep]
+
+    saga = SingleStepSaga()
+
+    session_factory = async_sessionmaker(
+        engine,
+        expire_on_commit=False,
+        autocommit=False,
+        autoflush=False,
+    )
+    storage = SqlAlchemySagaStorage(session_factory)
+    context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+
+    async def run_transaction() -> None:
+        """
+        Run the saga transaction to completion by iterating over its yielded steps using the configured context, container, and storage.
+
+        This function is used by benchmarks to execute a full saga flow without performing additional work per step.
+        """
+        async with saga.transaction(
+            context=context,
+            container=saga_container,
+            storage=storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: loop.run_until_complete(run_transaction()))
+
+
+# ---- Legacy path (no create_run, commit per storage call) ----
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize(
+    "storage_cls",
+    [SqlAlchemySagaStorage, SqlAlchemySagaStorageLegacy],
+    ids=["storage", "legacy"],
+)
+def test_benchmark_saga_sqlalchemy_legacy_full_transaction(
+    benchmark,
+    saga_sqlalchemy: Saga[OrderContext],
+    saga_container: SagaContainer,
+    saga_benchmark_loop_and_engine,
+    storage_cls,
+):
+    """Benchmark full saga transaction with SQLAlchemy storage, legacy path (MySQL)."""
+    loop, engine = saga_benchmark_loop_and_engine
+    storage = _make_storage(engine, storage_cls)
+    context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+
+    async def run_transaction() -> None:
+        async with saga_sqlalchemy.transaction(
+            context=context,
+            container=saga_container,
+            storage=storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: loop.run_until_complete(run_transaction()))
+
+
+@pytest.mark.benchmark
+@pytest.mark.parametrize(
+    "storage_cls",
+    [SqlAlchemySagaStorage, SqlAlchemySagaStorageLegacy],
+    ids=["storage", "legacy"],
+)
+def test_benchmark_saga_sqlalchemy_legacy_single_step(
+    benchmark,
+    saga_container: SagaContainer,
+    saga_benchmark_loop_and_engine,
+    storage_cls,
+):
+    """Benchmark saga with single step, legacy path (SQLAlchemy storage)."""
+    loop, engine = saga_benchmark_loop_and_engine
+
+    class SingleStepSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep]
+
+    saga = SingleStepSaga()
+    storage = _make_storage(engine, storage_cls)
+    context = OrderContext(order_id="ord_1", user_id="user_1", amount=100.0)
+
+    async def run_transaction() -> None:
+        async with saga.transaction(
+            context=context,
+            container=saga_container,
+            storage=storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    benchmark(lambda: loop.run_until_complete(run_transaction()))
diff --git a/tests/benchmarks/default/test_benchmark_serialization.py b/tests/benchmarks/default/test_benchmark_serialization.py
new file mode 100644
index 0000000..e4f6e1a
--- /dev/null
+++ b/tests/benchmarks/default/test_benchmark_serialization.py
@@ -0,0 +1,83 @@
+"""Benchmarks for serialization and deserialization (default Request/Response)."""
+
+import cqrs
+import pytest
+
+
+class SampleRequest(cqrs.Request):
+    field1: str
+    field2: int
+    field3: list[str]
+    field4: dict[str, int]
+
+
+class SampleResponse(cqrs.Response):
+    result: str
+    data: dict[str, str]
+
+
+@pytest.mark.benchmark
+def test_benchmark_request_to_dict(benchmark):
+    """Benchmark request serialization to dictionary."""
+    request = SampleRequest(
+        field1="test_value",
+        field2=42,
+        field3=["a", "b", "c"],
+        field4={"key1": 1, "key2": 2},
+    )
+
+    benchmark(lambda: request.to_dict())
+
+
+@pytest.mark.benchmark
+def test_benchmark_request_from_dict(benchmark):
+    """Benchmark request deserialization from dictionary."""
+    data = {
+        "field1": "test_value",
+        "field2": 42,
+        "field3": ["a", "b", "c"],
+        "field4": {"key1": 1, "key2": 2},
+    }
+
+    benchmark(lambda: SampleRequest.from_dict(**data))
+
+
+@pytest.mark.benchmark
+def test_benchmark_response_to_dict(benchmark):
+    """Benchmark response serialization to dictionary."""
+    response = SampleResponse(
+        result="success",
+        data={"key1": "value1", "key2": "value2"},
+    )
+
+    benchmark(lambda: response.to_dict())
+
+
+@pytest.mark.benchmark
+def test_benchmark_response_from_dict(benchmark):
+    """Benchmark response deserialization from dictionary."""
+    data = {
+        "result": "success",
+        "data": {"key1": "value1", "key2": "value2"},
+    }
+
+    benchmark(lambda: SampleResponse.from_dict(**data))
+
+
+@pytest.mark.benchmark
+def test_benchmark_complex_nested_structure(benchmark):
+    """Benchmark serialization of complex nested structures."""
+
+    class NestedRequest(cqrs.Request):
+        level1: dict[str, list[dict[str, str]]]
+        level2: list[dict[str, int]]
+
+    request = NestedRequest(
+        level1={
+            "group1": [{"name": "item1", "value": "val1"}] * 5,
+            "group2": [{"name": "item2", "value": "val2"}] * 5,
+        },
+        level2=[{"counter": i} for i in range(10)],
+    )
+
+    benchmark(lambda: request.to_dict())
diff --git a/tests/benchmarks/default/test_benchmark_stream_request_handler.py b/tests/benchmarks/default/test_benchmark_stream_request_handler.py
new file mode 100644
index 0000000..300fdaa
--- /dev/null
+++ b/tests/benchmarks/default/test_benchmark_stream_request_handler.py
@@ -0,0 +1,118 @@
+"""Benchmarks for StreamingRequestHandler (default Request/Response)."""
+
+import asyncio
+import typing
+
+import cqrs
+import di
+import pytest
+from cqrs.events.event import IEvent
+from cqrs.requests import bootstrap
+from cqrs.requests.request_handler import StreamingRequestHandler
+
+
+class ProcessItemsCommand(cqrs.Request):
+    item_ids: list[str]
+
+
+class ProcessItemResult(cqrs.Response):
+    item_id: str
+    status: str
+
+
+class StreamingHandler(StreamingRequestHandler[ProcessItemsCommand, ProcessItemResult]):
+    def __init__(self) -> None:
+        self._events: list[IEvent] = []
+
+    @property
+    def events(self) -> typing.Sequence[IEvent]:
+        return self._events.copy()
+
+    def clear_events(self) -> None:
+        self._events.clear()
+
+    async def handle(
+        self,
+        request: ProcessItemsCommand,
+    ) -> typing.AsyncIterator[ProcessItemResult]:
+        for item_id in request.item_ids:
+            self._events.append(
+                cqrs.NotificationEvent(
+                    event_name="ItemProcessed",
+                    payload={"item_id": item_id},
+                ),
+            )
+            yield ProcessItemResult(item_id=item_id, status="processed")
+
+
+def streaming_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(ProcessItemsCommand, StreamingHandler)
+
+
+@pytest.fixture
+def streaming_mediator():
+    return bootstrap.bootstrap_streaming(
+        di_container=di.Container(),
+        commands_mapper=streaming_mapper,
+    )
+
+
+@pytest.mark.benchmark
+def test_benchmark_stream_single_item(streaming_mediator, benchmark):
+    """Benchmark streaming handler with single item."""
+
+    async def run():
+        request = ProcessItemsCommand(item_ids=["item_1"])
+        results = []
+        async for result in streaming_mediator.stream(request):
+            results.append(result)
+        return results
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_stream_ten_items(streaming_mediator, benchmark):
+    """Benchmark streaming handler with 10 items."""
+
+    async def run():
+        request = ProcessItemsCommand(
+            item_ids=[f"item_{i}" for i in range(10)],
+        )
+        results = []
+        async for result in streaming_mediator.stream(request):
+            results.append(result)
+        return results
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_stream_hundred_items(streaming_mediator, benchmark):
+    """Benchmark streaming handler with 100 items."""
+
+    async def run():
+        request = ProcessItemsCommand(
+            item_ids=[f"item_{i}" for i in range(100)],
+        )
+        results = []
+        async for result in streaming_mediator.stream(request):
+            results.append(result)
+        return results
+
+    benchmark(lambda: asyncio.run(run()))
+
+
+@pytest.mark.benchmark
+def test_benchmark_stream_ten_requests_five_items_each(streaming_mediator, benchmark):
+    """Benchmark 10 streaming requests with 5 items each."""
+
+    async def run():
+        for i in range(10):
+            request = ProcessItemsCommand(
+                item_ids=[f"item_{i}_{j}" for j in range(5)],
+            )
+            async for _ in streaming_mediator.stream(request):
+                pass
+
+    benchmark(lambda: asyncio.run(run()))
diff --git a/tests/conftest.py b/tests/conftest.py
index b76341b..ee13e55 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -23,4 +23,6 @@ def event_loop():
 
 @pytest.fixture(scope="function")
 async def kafka_producer() -> kafka.KafkaProducer:
-    return mock.create_autospec(kafka.KafkaProducer)
+    producer = mock.create_autospec(kafka.KafkaProducer)
+    producer.produce = mock.AsyncMock()
+    return producer
diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py
new file mode 100644
index 0000000..562a0be
--- /dev/null
+++ b/tests/integration/conftest.py
@@ -0,0 +1,172 @@
+import typing
+
+import pytest
+import redis
+from aiobreaker.storage.memory import CircuitMemoryStorage
+from aiobreaker.storage.redis import CircuitRedisStorage
+from aiobreaker import CircuitBreakerState
+from unittest import mock
+
+import cqrs
+from cqrs import events
+from cqrs.requests.map import SagaMap
+from cqrs.saga.storage.sqlalchemy import SqlAlchemySagaStorage
+
+from tests.integration.test_saga_mediator_memory import (
+    FailingOrderSaga,
+    FailingStep,
+    InventoryReservedEvent,
+    InventoryReservedEventHandler,
+    OrderContext,
+    OrderShippedEvent,
+    OrderShippedEventHandler,
+    OrderSaga,
+    PaymentProcessedEvent,
+    PaymentProcessedEventHandler,
+    ProcessPaymentStep,
+    ReserveInventoryStep,
+    ShipOrderStep,
+)
+
+
+class _TestContainer:
+    """Test container that resolves step handlers, sagas, and event handlers (shared by SQLAlchemy mediator tests)."""
+
+    def __init__(self, storage: SqlAlchemySagaStorage) -> None:
+        self._storage = storage
+        self._external_container = None
+        self._step_handlers = {
+            ReserveInventoryStep: ReserveInventoryStep(),
+            ProcessPaymentStep: ProcessPaymentStep(),
+            ShipOrderStep: ShipOrderStep(),
+            FailingStep: FailingStep(),
+        }
+        self._event_handlers = {
+            InventoryReservedEventHandler: InventoryReservedEventHandler(),
+            PaymentProcessedEventHandler: PaymentProcessedEventHandler(),
+            OrderShippedEventHandler: OrderShippedEventHandler(),
+        }
+        self._sagas = {
+            OrderSaga: OrderSaga(),  # type: ignore[arg-type]
+            FailingOrderSaga: FailingOrderSaga(),  # type: ignore[arg-type]
+        }
+
+    @property
+    def external_container(self) -> typing.Any:
+        return self._external_container
+
+    def attach_external_container(self, container: typing.Any) -> None:
+        self._external_container = container
+
+    async def resolve(self, type_) -> typing.Any:
+        if type_ in self._step_handlers:
+            return self._step_handlers[type_]
+        if type_ in self._event_handlers:
+            return self._event_handlers[type_]
+        if type_ in self._sagas:
+            return self._sagas[type_]
+        if type_ == SqlAlchemySagaStorage:
+            return self._storage
+        raise ValueError(f"Unknown type: {type_}")
+
+
+@pytest.fixture
+def container(storage: SqlAlchemySagaStorage) -> _TestContainer:
+    """Create test container (shared by SQLAlchemy mediator tests; requires storage fixture from test module)."""
+    container = _TestContainer(storage)
+    for step_handler in container._step_handlers.values():
+        if hasattr(step_handler, "_events"):
+            step_handler._events.clear()
+    for event_handler in container._event_handlers.values():
+        if hasattr(event_handler, "handled_events"):
+            event_handler.handled_events.clear()
+    return container
+
+
+@pytest.fixture
+def saga_mediator(
+    container: _TestContainer,
+    storage: SqlAlchemySagaStorage,
+) -> cqrs.SagaMediator:
+    """Create SagaMediator with SqlAlchemySagaStorage (shared; storage comes from test module)."""
+
+    def saga_mapper(mapper: SagaMap) -> None:
+        mapper.bind(OrderContext, OrderSaga)
+
+    def events_mapper(mapper: events.EventMap) -> None:
+        mapper.bind(InventoryReservedEvent, InventoryReservedEventHandler)
+        mapper.bind(PaymentProcessedEvent, PaymentProcessedEventHandler)
+        mapper.bind(OrderShippedEvent, OrderShippedEventHandler)
+
+    event_map = events.EventMap()
+    events_mapper(event_map)
+    message_broker = mock.AsyncMock()
+    message_broker.produce = mock.AsyncMock()
+    event_emitter = events.EventEmitter(
+        event_map=event_map,
+        container=container,  # type: ignore
+        message_broker=message_broker,
+    )
+    saga_map = SagaMap()
+    saga_mapper(saga_map)
+    mediator = cqrs.SagaMediator(
+        saga_map=saga_map,
+        container=container,  # type: ignore
+        event_emitter=event_emitter,
+        event_map=event_map,
+        max_concurrent_event_handlers=2,
+        concurrent_event_handle_enable=True,
+        storage=storage,
+    )
+    return mediator
+
+
+@pytest.fixture
+def memory_storage_factory():
+    def _factory(name: str):
+        return CircuitMemoryStorage(state=CircuitBreakerState.CLOSED)
+
+    return _factory
+
+
+@pytest.fixture
+def redis_client():
+    """
+    Creates a real synchronous Redis client connected to the local instance.
+    Skips tests if Redis is not available.
+    """
+    # aiobreaker's CircuitRedisStorage uses synchronous Redis client methods
+    # decode_responses=False is critical because aiobreaker tries to .decode('utf-8') the state
+    client = redis.from_url(
+        "redis://localhost:6379",
+        encoding="utf-8",
+        decode_responses=False,
+    )
+    try:
+        client.ping()
+    except Exception as e:
+        client.close()
+        pytest.skip(
+            f"Redis is not available: {e}. Make sure 'docker-compose up' is running.",
+        )
+
+    yield client
+
+    # Clean up
+    try:
+        client.flushall()
+    except Exception:
+        pass
+    client.close()
+
+
+@pytest.fixture
+def redis_storage_factory(redis_client):
+    def _factory(name: str):
+        return CircuitRedisStorage(
+            state=CircuitBreakerState.CLOSED,
+            redis_object=redis_client,
+            namespace=name,
+        )
+
+    return _factory
diff --git a/tests/integration/fixtures.py b/tests/integration/fixtures.py
index 8965e73..cbb1f5b 100644
--- a/tests/integration/fixtures.py
+++ b/tests/integration/fixtures.py
@@ -11,6 +11,10 @@
 dotenv.load_dotenv()
 DATABASE_DSN = os.environ.get("DATABASE_DSN", "")
 
+# DSN для тестов саги: отдельные переменные для MySQL и PostgreSQL (задаются в pytest-config.ini / env).
+DATABASE_DSN_MYSQL = os.environ.get("DATABASE_DSN_MYSQL", "")
+DATABASE_DSN_POSTGRESQL = os.environ.get("DATABASE_DSN_POSTGRESQL", "")
+
 
 @pytest.fixture(scope="function")
 async def init_orm():
@@ -40,55 +44,69 @@ async def session(init_orm):
         yield session
 
 
-# Saga storage fixtures
+# --- Saga storage: MySQL (отдельные фикстуры, поднимают схему и всё необходимое) ---
+
+
 @pytest.fixture(scope="session")
-async def init_saga_orm():
-    """Initialize saga storage tables - drops and creates tables BEFORE test only."""
+async def init_saga_orm_mysql():
+    """Поднять схему саги для MySQL (DATABASE_DSN_MYSQL)."""
     from cqrs.saga.storage.sqlalchemy import Base
 
+    if not DATABASE_DSN_MYSQL:
+        pytest.skip("DATABASE_DSN_MYSQL not set")
     engine = create_async_engine(
-        DATABASE_DSN,
+        DATABASE_DSN_MYSQL,
         pool_pre_ping=True,
         pool_size=10,
         max_overflow=30,
         echo=False,
     )
-    # Drop and create tables BEFORE test (not after)
-    # Use begin() to ensure tables are created, but don't keep transaction open
     async with engine.begin() as connect:
         await connect.run_sync(Base.metadata.drop_all)
         await connect.run_sync(Base.metadata.create_all)
-
-    # Yield engine so it can be used for sessions
-    # Data will persist after test because we don't drop tables in cleanup
     yield engine
-
-    # Cleanup: dispose engine but DON'T drop tables - keep data in DB
     await engine.dispose()
 
 
 @pytest.fixture(scope="session")
-def saga_session_factory(init_saga_orm):
-    """Create a session factory for saga storage tests."""
-    engine = init_saga_orm
-    return async_sessionmaker(engine, expire_on_commit=False, autocommit=False)
+def saga_session_factory_mysql(init_saga_orm_mysql):
+    """Session factory для тестов саги на MySQL."""
+    return async_sessionmaker(
+        init_saga_orm_mysql,
+        expire_on_commit=False,
+        autocommit=False,
+    )
+
+
+# --- Saga storage: PostgreSQL (отдельные фикстуры, поднимают схему и всё необходимое) ---
 
 
 @pytest.fixture(scope="session")
-async def saga_session(saga_session_factory):
-    """Create a session for saga storage tests - commits data to persist."""
-    # Use autocommit=False but ensure we commit explicitly
-    session = saga_session_factory()
+async def init_saga_orm_postgres():
+    """Поднять схему саги для PostgreSQL (DATABASE_DSN_POSTGRESQL)."""
+    from cqrs.saga.storage.sqlalchemy import Base
 
-    async with contextlib.aclosing(session):
-        try:
-            yield session
-            # Final commit before closing to ensure data persists
-            if session.in_transaction():
-                await session.commit()
-        except Exception:
-            # Only rollback on exception
-            if session.in_transaction():
-                await session.rollback()
-            raise
-        # No cleanup that would delete data - data persists in DB
+    if not DATABASE_DSN_POSTGRESQL:
+        pytest.skip("DATABASE_DSN_POSTGRESQL not set")
+    engine = create_async_engine(
+        DATABASE_DSN_POSTGRESQL,
+        pool_pre_ping=True,
+        pool_size=10,
+        max_overflow=30,
+        echo=False,
+    )
+    async with engine.begin() as connect:
+        await connect.run_sync(Base.metadata.drop_all)
+        await connect.run_sync(Base.metadata.create_all)
+    yield engine
+    await engine.dispose()
+
+
+@pytest.fixture(scope="session")
+def saga_session_factory_postgres(init_saga_orm_postgres):
+    """Session factory для тестов саги на PostgreSQL."""
+    return async_sessionmaker(
+        init_saga_orm_postgres,
+        expire_on_commit=False,
+        autocommit=False,
+    )
diff --git a/tests/integration/test_event_handler_chain.py b/tests/integration/test_event_handler_chain.py
new file mode 100644
index 0000000..6cf15df
--- /dev/null
+++ b/tests/integration/test_event_handler_chain.py
@@ -0,0 +1,115 @@
+"""Integration test: 3-level event chain (L1 -> L2 -> L3) via RequestMediator + EventProcessor."""
+
+import asyncio
+import typing
+
+import di
+import pydantic
+
+import cqrs
+from cqrs.events.event import IEvent
+from cqrs.requests import bootstrap
+
+PROCESSED_L1: list[cqrs.DomainEvent] = []
+PROCESSED_L2: list[cqrs.DomainEvent] = []
+PROCESSED_L3: list[cqrs.DomainEvent] = []
+
+
+class EmitL1Command(cqrs.Request):
+    """Command that emits L1 event."""
+
+    seed: str = pydantic.Field()
+
+
+class EventL1(cqrs.DomainEvent, frozen=True):
+    level: int = 1
+    seed: str = pydantic.Field()
+
+
+class EventL2(cqrs.DomainEvent, frozen=True):
+    level: int = 2
+    seed: str = pydantic.Field()
+
+
+class EventL3(cqrs.DomainEvent, frozen=True):
+    level: int = 3
+    seed: str = pydantic.Field()
+
+
+class EmitL1CommandHandler(cqrs.RequestHandler[EmitL1Command, None]):
+    def __init__(self) -> None:
+        self._events: list[IEvent] = []
+
+    @property
+    def events(self) -> typing.Sequence[IEvent]:
+        return tuple(self._events)
+
+    async def handle(self, request: EmitL1Command) -> None:
+        self._events.append(EventL1(seed=request.seed))
+
+
+class HandlerL1(cqrs.EventHandler[EventL1]):
+    def __init__(self) -> None:
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> typing.Sequence[IEvent]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: EventL1) -> None:
+        PROCESSED_L1.append(event)
+        self._follow_ups.append(EventL2(seed=event.seed))
+
+
+class HandlerL2(cqrs.EventHandler[EventL2]):
+    def __init__(self) -> None:
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> typing.Sequence[IEvent]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: EventL2) -> None:
+        PROCESSED_L2.append(event)
+        self._follow_ups.append(EventL3(seed=event.seed))
+
+
+class HandlerL3(cqrs.EventHandler[EventL3]):
+    async def handle(self, event: EventL3) -> None:
+        PROCESSED_L3.append(event)
+
+
+def commands_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(EmitL1Command, EmitL1CommandHandler)
+
+
+def events_mapper(mapper: cqrs.EventMap) -> None:
+    mapper.bind(EventL1, HandlerL1)
+    mapper.bind(EventL2, HandlerL2)
+    mapper.bind(EventL3, HandlerL3)
+
+
+async def test_three_level_event_chain_via_request_mediator() -> None:
+    """Arrange: command emits L1; L1 handler returns L2; L2 returns L3; L3 returns ().
+    Act: mediator.send(command). Assert: L1, L2, L3 all processed."""
+    PROCESSED_L1.clear()
+    PROCESSED_L2.clear()
+    PROCESSED_L3.clear()
+
+    mediator = bootstrap.bootstrap(
+        di_container=di.Container(),
+        commands_mapper=commands_mapper,
+        domain_events_mapper=events_mapper,
+        max_concurrent_event_handlers=2,
+        concurrent_event_handle_enable=True,
+    )
+
+    await mediator.send(EmitL1Command(seed="x"))
+    await asyncio.sleep(0.15)
+
+    assert len(PROCESSED_L1) == 1
+    assert PROCESSED_L1[0].seed == "x"  # type: ignore[attr-defined]
+    assert len(PROCESSED_L2) == 1
+    assert PROCESSED_L2[0].seed == "x"  # type: ignore[attr-defined]
+    assert len(PROCESSED_L3) == 1
+    assert PROCESSED_L3[0].seed == "x"  # type: ignore[attr-defined]
diff --git a/tests/integration/test_event_outbox.py b/tests/integration/test_event_outbox.py
index bb0f542..40b11e7 100644
--- a/tests/integration/test_event_outbox.py
+++ b/tests/integration/test_event_outbox.py
@@ -33,7 +33,7 @@ def __init__(self, repository: cqrs.OutboxedEventRepository):
         self.repository = repository
 
     @property
-    def events(self) -> list[events.Event]:
+    def events(self) -> typing.Sequence[events.IEvent]:
         return []
 
     async def handle(self, request: OutboxRequest) -> None:
@@ -61,9 +61,7 @@ async def test_outbox_add_3_event_positive(self, session):
         request = OutboxRequest(message="test_outbox_add_3_event_positive", count=3)
         await OutboxRequestHandler(repository).handle(request)
 
-        not_produced_events: typing.List[
-            outbox_repository.OutboxedEvent
-        ] = await repository.get_many(3)
+        not_produced_events: typing.List[outbox_repository.OutboxedEvent] = await repository.get_many(3)
         await session.commit()
 
         assert len(not_produced_events) == 3
@@ -109,7 +107,7 @@ async def test_get_new_events_negative(self, session):
         events_list = await repository.get_many(3)
         await repository.update_status(
             events_list[-1].id,
-            repository_protocol.EventStatus.PRODUCED,
+            repository_protocol.EventStatus.PRODUCED,  # type: ignore[arg-type]
         )
         await session.commit()
 
@@ -156,7 +154,7 @@ async def test_get_new_event_negative(self, session):
         [event_over_get_all_events_method] = await repository.get_many(1)
         await repository.update_status(
             event_over_get_all_events_method.id,
-            repository_protocol.EventStatus.PRODUCED,
+            repository_protocol.EventStatus.PRODUCED,  # type: ignore[arg-type]
         )
         await session.commit()
 
@@ -180,7 +178,7 @@ async def test_mark_as_failure_positive(self, session):
         # mark FIRST event as failure
         await repository.update_status(
             failure_event.id,
-            repository_protocol.EventStatus.NOT_PRODUCED,
+            repository_protocol.EventStatus.NOT_PRODUCED,  # type: ignore[arg-type]
         )
         await session.commit()
 
@@ -204,7 +202,7 @@ async def test_mark_as_failure_negative(self, session):
         for _ in range(sqlalchemy.MAX_FLUSH_COUNTER_VALUE):
             await repository.update_status(
                 failure_event.id,
-                repository_protocol.EventStatus.NOT_PRODUCED,
+                repository_protocol.EventStatus.NOT_PRODUCED,  # type: ignore[arg-type]
             )
 
         await session.commit()
diff --git a/tests/integration/test_kafka_producer.py b/tests/integration/test_kafka_producer.py
index 579df20..b4e9d19 100644
--- a/tests/integration/test_kafka_producer.py
+++ b/tests/integration/test_kafka_producer.py
@@ -1,3 +1,4 @@
+import asyncio
 import typing
 import uuid
 
@@ -77,6 +78,9 @@ async def test_produce_some_event(
 
     await mediator.send(command)
 
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert handler
     assert handler.called
     assert kafka_producer.produce.called
diff --git a/tests/integration/test_pybreaker_adapter.py b/tests/integration/test_pybreaker_adapter.py
new file mode 100644
index 0000000..0746784
--- /dev/null
+++ b/tests/integration/test_pybreaker_adapter.py
@@ -0,0 +1,359 @@
+"""Integration tests for AioBreakerAdapter."""
+
+import asyncio
+import uuid
+import pytest
+from aiobreaker import CircuitBreakerError
+
+from cqrs.adapters.circuit_breaker import AioBreakerAdapter
+from cqrs.saga.step import SagaStepHandler
+
+
+# Test exceptions
+class BusinessException(Exception):
+    """Business exception that should not open circuit breaker."""
+
+    pass
+
+
+class NetworkException(Exception):
+    """Network exception that should open circuit breaker."""
+
+    pass
+
+
+# Test async functions
+async def successful_function(value: int) -> int:
+    """Successful async function."""
+    await asyncio.sleep(0.01)
+    return value * 2
+
+
+async def failing_function(error_type: type[Exception] = RuntimeError) -> None:
+    """Failing async function."""
+    await asyncio.sleep(0.01)
+    raise error_type("Function failed")
+
+
+async def slow_function(delay: float = 0.1) -> str:
+    """Slow async function."""
+    await asyncio.sleep(delay)
+    return "completed"
+
+
+# Helper functions
+def create_test_step(module_name: str) -> type[SagaStepHandler]:
+    """Create a test step type with unique module name."""
+
+    class TestStep(SagaStepHandler):
+        __module__ = f"{module_name}_{uuid.uuid4().hex[:8]}"
+
+    return TestStep
+
+
+class TestAioBreakerAdapter:
+    """
+    Integration tests for AioBreakerAdapter with different storage backends.
+
+    This class combines positive and negative tests and runs them against
+    both Memory and Redis storage backends.
+    """
+
+    @pytest.fixture(params=["memory", "redis"])
+    def adapter(self, request, memory_storage_factory, redis_storage_factory):
+        """
+        Fixture providing AioBreakerAdapter with different storage backends.
+        Parameterized to run tests with both memory and redis storage.
+        """
+        if request.param == "memory":
+            factory = memory_storage_factory
+        else:
+            factory = redis_storage_factory
+
+        return AioBreakerAdapter(
+            fail_max=3,
+            timeout_duration=2,
+            storage_factory=factory,
+        )
+
+    @pytest.mark.asyncio
+    async def test_successful_execution(self, adapter):
+        """Test successful function execution through adapter."""
+        # Arrange
+        step_type = create_test_step("test_success")
+
+        # Act
+        result = await adapter.call(
+            identifier=step_type,
+            func=successful_function,
+            value=5,
+        )
+
+        # Assert
+        assert result == 10
+
+    @pytest.mark.asyncio
+    async def test_namespace_isolation(self, adapter):
+        """Test that different step types have isolated circuit breaker states."""
+        # Arrange
+        step_type_1 = create_test_step("test_isolation_1")
+        step_type_2 = create_test_step("test_isolation_2")
+
+        # Act - Fail Step1 twice (circuit still closed)
+        for _ in range(2):
+            with pytest.raises(RuntimeError):
+                await adapter.call(
+                    identifier=step_type_1,
+                    func=failing_function,
+                    error_type=RuntimeError,
+                )
+
+        # Act - Step2 should still work (different namespace)
+        result = await adapter.call(
+            identifier=step_type_2,
+            func=successful_function,
+            value=3,
+        )
+
+        # Assert
+        assert result == 6
+
+        # Act - Step1 circuit should still be closed (only 2 failures, need 3 to open)
+        with pytest.raises(CircuitBreakerError):
+            await adapter.call(
+                identifier=step_type_1,
+                func=failing_function,
+                error_type=RuntimeError,
+            )
+
+        # Now circuit should be open (3 failures reached)
+        with pytest.raises(CircuitBreakerError):
+            await adapter.call(
+                identifier=step_type_1,
+                func=failing_function,
+                error_type=RuntimeError,
+            )
+
+    @pytest.mark.asyncio
+    async def test_business_exception_exclusion(self, adapter):
+        """Test that business exceptions don't open circuit breaker."""
+        # Note: We need to create a new adapter here to set exclude list,
+        # but we want to reuse the storage factory mechanism.
+        # However, AioBreakerAdapter is created in fixture.
+        # We can test this by checking if BusinessException is propagated without opening circuit.
+
+        # We can't easily modify the fixture-created adapter's exclude list after init.
+        # But we can create a specific test method that uses the factories directly if needed,
+        # or update the fixture to accept parameters (too complex).
+        # Alternatively, we can rely on the fact that the fixture uses default settings (fail_max=3).
+
+        # Let's manually create an adapter using the storage factory from the fixture if possible.
+        # Since we can't access the factory easily from the 'adapter' instance,
+        # we will rely on a separate test or modify this test to use the factories.
+        pass
+
+    @pytest.mark.asyncio
+    async def test_circuit_reset_after_timeout(self, adapter):
+        """Test that circuit breaker resets after timeout."""
+        # Arrange
+        step_type = create_test_step("test_reset")
+
+        # Act - Open circuit with failures
+        for _ in range(3):
+            try:
+                await adapter.call(
+                    identifier=step_type,
+                    func=failing_function,
+                    error_type=RuntimeError,
+                )
+            except (RuntimeError, CircuitBreakerError):
+                pass
+
+        # Assert - Circuit should be open now
+        with pytest.raises(CircuitBreakerError):
+            await adapter.call(
+                identifier=step_type,
+                func=failing_function,
+                error_type=RuntimeError,
+            )
+
+        # Act - Wait for reset timeout
+        await asyncio.sleep(2.5)
+
+        # Assert - Circuit should be half-open, trial call fails and circuit opens again
+        with pytest.raises(CircuitBreakerError):
+            await adapter.call(
+                identifier=step_type,
+                func=failing_function,
+                error_type=RuntimeError,
+            )
+
+    @pytest.mark.asyncio
+    async def test_is_circuit_breaker_error(self, adapter):
+        """Test is_circuit_breaker_error method."""
+        # Arrange
+        step_type = create_test_step("test_error_check")
+
+        # Act - Open circuit
+        for _ in range(3):
+            try:
+                await adapter.call(
+                    identifier=step_type,
+                    func=failing_function,
+                    error_type=RuntimeError,
+                )
+            except Exception:
+                pass
+
+        # Act - Try to call when circuit is open
+        try:
+            await adapter.call(
+                identifier=step_type,
+                func=failing_function,
+                error_type=RuntimeError,
+            )
+        except Exception as e:
+            # Assert - Check if it's a circuit breaker error
+            assert adapter.is_circuit_breaker_error(e)
+            assert isinstance(e, CircuitBreakerError)
+
+    @pytest.mark.asyncio
+    async def test_circuit_opens_after_failures(self, adapter):
+        """Test that circuit opens after exceeding fail_max."""
+        # Arrange
+        step_type = create_test_step("test_opens")
+
+        # Act - Fail exactly fail_max times (3)
+        for _ in range(2):
+            with pytest.raises(RuntimeError):
+                await adapter.call(
+                    identifier=step_type,
+                    func=failing_function,
+                    error_type=RuntimeError,
+                )
+
+        # Third call should raise CircuitBreakerError (or RuntimeError then open)
+        # In aiobreaker, the call that reaches the threshold fails with the original error,
+        # and SUBSEQUENT calls fail with CircuitBreakerError.
+        # Wait, let's verify aiobreaker behavior.
+        # Usually:
+        # 1. Fail -> count=1
+        # 2. Fail -> count=2
+        # 3. Fail -> count=3 (>= max). State becomes OPEN. Exception is RuntimeError.
+        # 4. Call -> CircuitBreakerError.
+
+        # With fail_max=3:
+        # Call 3 raises CircuitBreakerError (not RuntimeError)
+        with pytest.raises(CircuitBreakerError):  # The 3rd failure
+            await adapter.call(
+                identifier=step_type,
+                func=failing_function,
+                error_type=RuntimeError,
+            )
+
+        # Call 4 raises CircuitBreakerError
+        with pytest.raises(CircuitBreakerError):
+            await adapter.call(
+                identifier=step_type,
+                func=failing_function,
+                error_type=RuntimeError,
+            )
+
+    @pytest.mark.asyncio
+    async def test_custom_configuration(
+        self,
+        request,
+        memory_storage_factory,
+        redis_storage_factory,
+    ):
+        """Test adapter with custom configuration (exclude exceptions)."""
+        # We need to manually parameterize the factory here or duplicate logic
+        # Ideally we'd use the fixture, but we need to pass args to constructor.
+
+        # Let's iterate over both factories manually for this specific test
+        # or rely on the fact that if it works for one, it likely works for others regarding 'exclude' logic,
+        # but 'storage' logic is what we want to ensure works with 'exclude'.
+
+        factories = [memory_storage_factory, redis_storage_factory]
+
+        for factory in factories:
+            adapter = AioBreakerAdapter(
+                fail_max=2,
+                timeout_duration=1,
+                exclude=[BusinessException],
+                storage_factory=factory,
+            )
+            step_type = create_test_step("test_custom_config")
+
+            # Act - Fail with business exception (should not count)
+            for _ in range(3):
+                with pytest.raises(BusinessException):
+                    await adapter.call(
+                        identifier=step_type,
+                        func=failing_function,
+                        error_type=BusinessException,
+                    )
+
+            # Act - Fail with network exception (should count)
+            # 1st failure
+            with pytest.raises(NetworkException):
+                await adapter.call(
+                    identifier=step_type,
+                    func=failing_function,
+                    error_type=NetworkException,
+                )
+
+            # 2nd failure -> Open. Should raise CircuitBreakerError immediately
+            with pytest.raises(CircuitBreakerError):
+                await adapter.call(
+                    identifier=step_type,
+                    func=failing_function,
+                    error_type=NetworkException,
+                )
+
+            # 3rd call -> CircuitBreakerError
+            with pytest.raises(CircuitBreakerError):
+                await adapter.call(
+                    identifier=step_type,
+                    func=failing_function,
+                    error_type=NetworkException,
+                )
+
+    @pytest.mark.asyncio
+    async def test_concurrent_calls(self, adapter):
+        """Test behavior with multiple concurrent calls."""
+        # Arrange
+        step_type = create_test_step("test_concurrent")
+
+        # Open circuit
+        for _ in range(3):
+            try:
+                await adapter.call(
+                    identifier=step_type,
+                    func=failing_function,
+                    error_type=RuntimeError,
+                )
+            except Exception:
+                pass
+
+        # Verify open
+        with pytest.raises(CircuitBreakerError):
+            await adapter.call(
+                identifier=step_type,
+                func=failing_function,
+                error_type=RuntimeError,
+            )
+
+        # Concurrent calls should all fail fast
+        tasks = [
+            adapter.call(
+                identifier=step_type,
+                func=failing_function,
+                error_type=RuntimeError,
+            )
+            for _ in range(5)
+        ]
+
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        for res in results:
+            assert isinstance(res, CircuitBreakerError)
diff --git a/tests/integration/test_saga_mediator_memory.py b/tests/integration/test_saga_mediator_memory.py
index aef29e9..b64139d 100644
--- a/tests/integration/test_saga_mediator_memory.py
+++ b/tests/integration/test_saga_mediator_memory.py
@@ -1,5 +1,6 @@
 """Integration tests for SagaMediator with MemorySagaStorage."""
 
+import asyncio
 import dataclasses
 import typing
 import uuid
@@ -346,6 +347,25 @@ def events_mapper(mapper: events.EventMap) -> None:
 class TestSagaMediatorMemoryStorage:
     """Integration tests for SagaMediator with MemorySagaStorage."""
 
+    async def test_saga_mediator_stream_returns_async_iterator_consumable_with_async_for(
+        self,
+        saga_mediator: cqrs.SagaMediator,
+    ) -> None:
+        """
+        Contract: mediator.stream(context) is called without await
+        and returns an AsyncIterator that is consumed with async for.
+        """
+        context = OrderContext(order_id="contract", user_id="user1", amount=50.0)
+        # stream() is called (no await) and returns async iterator
+        async_gen = saga_mediator.stream(context)
+        step_results = []
+        async for result in async_gen:
+            step_results.append(result)
+        assert len(step_results) == 3
+        assert step_results[0].step_type == ReserveInventoryStep
+        assert step_results[1].step_type == ProcessPaymentStep
+        assert step_results[2].step_type == ShipOrderStep
+
     async def test_saga_mediator_executes_saga_successfully(
         self,
         saga_mediator: cqrs.SagaMediator,
@@ -396,6 +416,9 @@ async def test_saga_mediator_processes_events_from_steps(
         async for result in saga_mediator.stream(context):
             step_results.append(result)
 
+        # Wait for background tasks to complete
+        await asyncio.sleep(0.1)
+
         # Verify step results were returned
         assert len(step_results) == 3
         assert isinstance(step_results[0].response, ReserveInventoryResponse)
@@ -425,6 +448,9 @@ async def test_saga_mediator_emits_events(
         async for result in saga_mediator.stream(context):
             step_results.append(result)
 
+        # Wait for background tasks to complete
+        await asyncio.sleep(0.1)
+
         # Verify events were processed (DomainEvent calls handlers, not message broker)
         # Note: events are processed twice - once via dispatcher and once via emitter
         # Check that event handlers were called at least once
diff --git a/tests/integration/test_saga_mediator_sqlalchemy.py b/tests/integration/test_saga_mediator_sqlalchemy_mysql.py
similarity index 54%
rename from tests/integration/test_saga_mediator_sqlalchemy.py
rename to tests/integration/test_saga_mediator_sqlalchemy_mysql.py
index 6326f59..833b2d6 100644
--- a/tests/integration/test_saga_mediator_sqlalchemy.py
+++ b/tests/integration/test_saga_mediator_sqlalchemy_mysql.py
@@ -1,6 +1,5 @@
-"""Integration tests for SagaMediator with SqlAlchemySagaStorage."""
+"""Integration tests for SagaMediator with SqlAlchemySagaStorage (MySQL)."""
 
-import typing
 import uuid
 from unittest import mock
 
@@ -8,22 +7,17 @@
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 
 import cqrs
-from cqrs import events
-from cqrs.requests.map import SagaMap
+from cqrs import events, SagaMap
 from cqrs.saga.storage.enums import SagaStatus
 from cqrs.saga.storage.sqlalchemy import SqlAlchemySagaStorage
 
-# Import test models from memory test file
 from tests.integration.test_saga_mediator_memory import (
+    _TestContainer,
     FailingOrderSaga,
-    FailingStep,
-    InventoryReservedEvent,
     InventoryReservedEventHandler,
     OrderContext,
-    OrderShippedEvent,
-    OrderShippedEventHandler,
     OrderSaga,
-    PaymentProcessedEvent,
+    OrderShippedEventHandler,
     PaymentProcessedEventHandler,
     ProcessPaymentResponse,
     ProcessPaymentStep,
@@ -34,158 +28,35 @@
 )
 
 
-# Container setup (reuse from memory test)
-class _TestContainer:
-    """Test container that resolves step handlers, sagas, and event handlers."""
-
-    def __init__(self, storage: SqlAlchemySagaStorage) -> None:
-        self._storage = storage
-        self._external_container = None
-        self._step_handlers = {
-            ReserveInventoryStep: ReserveInventoryStep(),
-            ProcessPaymentStep: ProcessPaymentStep(),
-            ShipOrderStep: ShipOrderStep(),
-            FailingStep: FailingStep(),
-        }
-        self._event_handlers = {
-            InventoryReservedEventHandler: InventoryReservedEventHandler(),
-            PaymentProcessedEventHandler: PaymentProcessedEventHandler(),
-            OrderShippedEventHandler: OrderShippedEventHandler(),
-        }
-        # Create sagas with this container and storage
-        self._sagas = {
-            OrderSaga: OrderSaga(),  # type: ignore[arg-type]
-            FailingOrderSaga: FailingOrderSaga(),  # type: ignore[arg-type]
-        }
-
-    @property
-    def external_container(self) -> typing.Any:
-        """Return external container (for Container protocol compatibility)."""
-        return self._external_container
-
-    def attach_external_container(self, container: typing.Any) -> None:
-        """Attach external container (for Container protocol compatibility)."""
-        self._external_container = container
-
-    async def resolve(self, type_) -> typing.Any:
-        """Resolve type from container."""
-        if type_ in self._step_handlers:
-            return self._step_handlers[type_]
-        if type_ in self._event_handlers:
-            return self._event_handlers[type_]
-        if type_ in self._sagas:
-            return self._sagas[type_]
-        if type_ == SqlAlchemySagaStorage:
-            return self._storage
-        raise ValueError(f"Unknown type: {type_}")
-
-
 @pytest.fixture
 def storage(
-    saga_session_factory: async_sessionmaker[AsyncSession],
+    saga_session_factory_mysql: async_sessionmaker[AsyncSession],
 ) -> SqlAlchemySagaStorage:
-    """Create SqlAlchemySagaStorage instance."""
-    return SqlAlchemySagaStorage(saga_session_factory)
-
-
-@pytest.fixture
-def container(storage: SqlAlchemySagaStorage) -> _TestContainer:
-    """Create test container."""
-    container = _TestContainer(storage)
-    # Clear events in step handlers before each test
-    for step_handler in container._step_handlers.values():
-        if hasattr(step_handler, "_events"):
-            step_handler._events.clear()
-    # Clear events in event handlers before each test
-    for event_handler in container._event_handlers.values():
-        if hasattr(event_handler, "handled_events"):
-            event_handler.handled_events.clear()
-    return container
-
-
-@pytest.fixture
-def saga_mediator(
-    container: _TestContainer,
-    storage: SqlAlchemySagaStorage,
-) -> cqrs.SagaMediator:
-    """Create SagaMediator with SqlAlchemySagaStorage."""
-
-    def saga_mapper(mapper: SagaMap) -> None:
-        mapper.bind(OrderContext, OrderSaga)
-
-    def events_mapper(mapper: events.EventMap) -> None:
-        mapper.bind(InventoryReservedEvent, InventoryReservedEventHandler)
-        mapper.bind(PaymentProcessedEvent, PaymentProcessedEventHandler)
-        mapper.bind(OrderShippedEvent, OrderShippedEventHandler)
-
-    # Create event emitter
-    event_map = events.EventMap()
-    events_mapper(event_map)
-
-    message_broker = mock.AsyncMock()
-    message_broker.produce = mock.AsyncMock()
-
-    event_emitter = events.EventEmitter(
-        event_map=event_map,
-        container=container,  # type: ignore
-        message_broker=message_broker,
-    )
-
-    # Create mediator directly
-    saga_map = SagaMap()
-    saga_mapper(saga_map)
-
-    mediator = cqrs.SagaMediator(
-        saga_map=saga_map,
-        container=container,  # type: ignore
-        event_emitter=event_emitter,
-        event_map=event_map,
-        max_concurrent_event_handlers=2,
-        concurrent_event_handle_enable=True,
-        storage=storage,
-    )
+    """Create SqlAlchemySagaStorage instance (MySQL)."""
+    return SqlAlchemySagaStorage(saga_session_factory_mysql)
 
-    return mediator
 
-
-class TestSagaMediatorSqlAlchemyStorage:
-    """Integration tests for SagaMediator with SqlAlchemySagaStorage."""
+class TestSagaMediatorSqlAlchemyStorageMysql:
+    """Integration tests for SagaMediator with SqlAlchemySagaStorage (MySQL)."""
 
     async def test_saga_mediator_executes_saga_successfully(
         self,
         saga_mediator: cqrs.SagaMediator,
         storage: SqlAlchemySagaStorage,
     ) -> None:
-        """Test that SagaMediator executes saga successfully with SQLAlchemy storage."""
         context = OrderContext(order_id="123", user_id="user1", amount=100.0)
         saga_id = uuid.uuid4()
-
         step_results = []
         async for result in saga_mediator.stream(context, saga_id=saga_id):
             step_results.append(result)
-
-        # Verify all steps were executed
         assert len(step_results) == 3
-
-        # Verify step results
         assert isinstance(step_results[0].response, ReserveInventoryResponse)
         assert step_results[0].response.inventory_id == "inv_123"
-        assert step_results[0].response.reserved is True
-
         assert isinstance(step_results[1].response, ProcessPaymentResponse)
-        assert step_results[1].response.payment_id == "pay_123"
-        assert step_results[1].response.charged is True
-
         assert isinstance(step_results[2].response, ShipOrderResponse)
-        assert step_results[2].response.shipment_id == "ship_123"
-        assert step_results[2].response.shipped is True
-
-        # Verify step types
         assert step_results[0].step_type == ReserveInventoryStep
         assert step_results[1].step_type == ProcessPaymentStep
         assert step_results[2].step_type == ShipOrderStep
-
-        # Verify saga status in storage
         status, stored_context, version = await storage.load_saga_state(saga_id)
         assert status == SagaStatus.COMPLETED
 
@@ -194,24 +65,14 @@ async def test_saga_mediator_processes_events_from_steps(
         saga_mediator: cqrs.SagaMediator,
         container: _TestContainer,
     ) -> None:
-        """Test that SagaMediator processes events from steps."""
         context = OrderContext(order_id="456", user_id="user2", amount=200.0)
-
         step_results = []
         async for result in saga_mediator.stream(context):
             step_results.append(result)
-
-        # Verify step results were returned
         assert len(step_results) == 3
-        assert isinstance(step_results[0].response, ReserveInventoryResponse)
-        assert isinstance(step_results[1].response, ProcessPaymentResponse)
-        assert isinstance(step_results[2].response, ShipOrderResponse)
-
-        # Verify event handlers were called (events are processed internally)
         inventory_handler = await container.resolve(InventoryReservedEventHandler)
         payment_handler = await container.resolve(PaymentProcessedEventHandler)
         shipping_handler = await container.resolve(OrderShippedEventHandler)
-
         assert len(inventory_handler.handled_events) >= 1
         assert len(payment_handler.handled_events) >= 1
         assert len(shipping_handler.handled_events) >= 1
@@ -221,18 +82,12 @@ async def test_saga_mediator_emits_events(
         saga_mediator: cqrs.SagaMediator,
         container: _TestContainer,
     ) -> None:
-        """Test that SagaMediator processes events via EventEmitter."""
         context = OrderContext(order_id="789", user_id="user3", amount=300.0)
-
-        step_results = []
         async for result in saga_mediator.stream(context):
-            step_results.append(result)
-
-        # Verify events were processed
+            pass
         inventory_handler = await container.resolve(InventoryReservedEventHandler)
         payment_handler = await container.resolve(PaymentProcessedEventHandler)
         shipping_handler = await container.resolve(OrderShippedEventHandler)
-
         assert len(inventory_handler.handled_events) >= 1
         assert len(payment_handler.handled_events) >= 1
         assert len(shipping_handler.handled_events) >= 1
@@ -242,22 +97,17 @@ async def test_saga_mediator_handles_saga_failure_with_compensation(
         container: _TestContainer,
         storage: SqlAlchemySagaStorage,
     ) -> None:
-        """Test that SagaMediator handles saga failure and compensation."""
-
-        # Create mediator with failing saga
         def failing_saga_mapper(mapper: SagaMap) -> None:
             mapper.bind(OrderContext, FailingOrderSaga)
 
         saga_map = SagaMap()
         failing_saga_mapper(saga_map)
-
         event_map = events.EventMap()
         event_emitter = events.EventEmitter(
             event_map=event_map,
             container=container,  # type: ignore
             message_broker=mock.AsyncMock(),
         )
-
         failing_mediator = cqrs.SagaMediator(
             saga_map=saga_map,
             container=container,  # type: ignore
@@ -265,25 +115,17 @@ def failing_saga_mapper(mapper: SagaMap) -> None:
             event_map=event_map,
             storage=storage,
         )
-
         context = OrderContext(order_id="fail_123", user_id="user4", amount=400.0)
         saga_id = uuid.uuid4()
-
         step_results = []
         with pytest.raises(ValueError, match="Step failed for order fail_123"):
             async for result in failing_mediator.stream(context, saga_id=saga_id):
                 step_results.append(result)
-
-        # Verify that some steps were executed before failure
         assert len(step_results) >= 1
-
-        # Verify compensation was called
         reserve_step = await container.resolve(ReserveInventoryStep)
         payment_step = await container.resolve(ProcessPaymentStep)
         assert reserve_step.compensate_called
         assert payment_step.compensate_called
-
-        # Verify saga status is FAILED
         status, _, version = await storage.load_saga_state(saga_id)
         assert status == SagaStatus.FAILED
 
@@ -292,37 +134,21 @@ async def test_saga_mediator_with_saga_id_recovery(
         saga_mediator: cqrs.SagaMediator,
         storage: SqlAlchemySagaStorage,
     ) -> None:
-        """Test that SagaMediator can recover saga using saga_id."""
         context = OrderContext(order_id="recover_123", user_id="user5", amount=500.0)
         saga_id = uuid.uuid4()
-
-        # Execute first part of saga
         step_results_1 = []
         async for result in saga_mediator.stream(context, saga_id=saga_id):
             step_results_1.append(result)
-            # Simulate interruption after first step
             if len(step_results_1) == 1:
                 break
-
-        # Verify first step was executed
         assert len(step_results_1) == 1
         assert isinstance(step_results_1[0].response, ReserveInventoryResponse)
-        assert step_results_1[0].step_type == ReserveInventoryStep
-
-        # Verify saga is in RUNNING status
         status, _, version = await storage.load_saga_state(saga_id)
         assert status == SagaStatus.RUNNING
-
-        # Resume saga execution with same saga_id
         step_results_2 = []
         async for result in saga_mediator.stream(context, saga_id=saga_id):
             step_results_2.append(result)
-
-        # Verify remaining steps were executed
-        # Note: Saga will skip already completed steps
-        assert len(step_results_2) >= 2  # At least 2 more steps
-
-        # Verify final status
+        assert len(step_results_2) >= 2
         final_status, _, version = await storage.load_saga_state(saga_id)
         assert final_status == SagaStatus.COMPLETED
 
@@ -330,9 +156,8 @@ async def test_saga_mediator_persistence_across_sessions(
         self,
         container: _TestContainer,
         storage: SqlAlchemySagaStorage,
-        saga_session_factory: async_sessionmaker[AsyncSession],
+        saga_session_factory_mysql: async_sessionmaker[AsyncSession],
     ) -> None:
-        """Test that saga state persists across different storage instances."""
         context = OrderContext(order_id="persist_123", user_id="user6", amount=600.0)
         saga_id = uuid.uuid4()
 
@@ -341,14 +166,12 @@ def saga_mapper(mapper: SagaMap) -> None:
 
         saga_map = SagaMap()
         saga_mapper(saga_map)
-
         event_map = events.EventMap()
         event_emitter = events.EventEmitter(
             event_map=event_map,
             container=container,  # type: ignore
             message_broker=mock.AsyncMock(),
         )
-
         mediator = cqrs.SagaMediator(
             saga_map=saga_map,
             container=container,  # type: ignore
@@ -356,19 +179,14 @@ def saga_mapper(mapper: SagaMap) -> None:
             event_map=event_map,
             storage=storage,
         )
-
-        # Execute first step
         step_results_1 = []
         async for result in mediator.stream(context, saga_id=saga_id):
             step_results_1.append(result)
             if len(step_results_1) == 1:
                 break
-
-        # Create new storage instance and verify persistence
-        new_storage = SqlAlchemySagaStorage(saga_session_factory)
+        new_storage = SqlAlchemySagaStorage(saga_session_factory_mysql)
         status, stored_context, version = await new_storage.load_saga_state(saga_id)
         assert status == SagaStatus.RUNNING
-
         history = await new_storage.get_step_history(saga_id)
         assert len(history) >= 1
         assert history[0].step_name == "ReserveInventoryStep"
@@ -378,33 +196,46 @@ async def test_saga_mediator_concurrent_sagas(
         saga_mediator: cqrs.SagaMediator,
         storage: SqlAlchemySagaStorage,
     ) -> None:
-        """Test that SagaMediator handles multiple concurrent sagas."""
-        contexts = [
-            OrderContext(order_id=f"order_{i}", user_id=f"user_{i}", amount=100.0 * i)
-            for i in range(3)
-        ]
-        saga_ids = [uuid.uuid4() for _ in range(3)]
-
-        # Execute sagas concurrently
         import asyncio
 
+        contexts = [OrderContext(order_id=f"order_{i}", user_id=f"user_{i}", amount=100.0 * i) for i in range(3)]
+        saga_ids = [uuid.uuid4() for _ in range(3)]
+
         async def execute_saga(context: OrderContext, saga_id: uuid.UUID) -> list:
             results = []
             async for result in saga_mediator.stream(context, saga_id=saga_id):
                 results.append(result)
             return results
 
-        tasks = [
-            execute_saga(context, saga_id)
-            for context, saga_id in zip(contexts, saga_ids)
-        ]
+        tasks = [execute_saga(context, saga_id) for context, saga_id in zip(contexts, saga_ids)]
         all_results = await asyncio.gather(*tasks)
-
-        # Verify all sagas completed
         assert len(all_results) == 3
         assert all(len(results) == 3 for results in all_results)
-
-        # Verify all sagas are in COMPLETED status
         for saga_id in saga_ids:
             status, _, version = await storage.load_saga_state(saga_id)
             assert status == SagaStatus.COMPLETED
+
+    async def test_saga_mediator_concurrent_saga_creation_no_deadlock(
+        self,
+        saga_mediator: cqrs.SagaMediator,
+        storage: SqlAlchemySagaStorage,
+    ) -> None:
+        import asyncio
+
+        n = 10
+        contexts = [OrderContext(order_id=f"order_{i}", user_id=f"user_{i}", amount=100.0 * (i + 1)) for i in range(n)]
+        saga_ids = [uuid.uuid4() for _ in range(n)]
+
+        async def execute_saga(context: OrderContext, saga_id: uuid.UUID) -> list:
+            results = []
+            async for result in saga_mediator.stream(context, saga_id=saga_id):
+                results.append(result)
+            return results
+
+        tasks = [execute_saga(context, saga_id) for context, saga_id in zip(contexts, saga_ids)]
+        all_results = await asyncio.gather(*tasks)
+        assert len(all_results) == n
+        assert all(len(results) == 3 for results in all_results)
+        for saga_id in saga_ids:
+            status, _, _ = await storage.load_saga_state(saga_id)
+            assert status == SagaStatus.COMPLETED
diff --git a/tests/integration/test_saga_mediator_sqlalchemy_postgres.py b/tests/integration/test_saga_mediator_sqlalchemy_postgres.py
new file mode 100644
index 0000000..bb93dfd
--- /dev/null
+++ b/tests/integration/test_saga_mediator_sqlalchemy_postgres.py
@@ -0,0 +1,241 @@
+"""Integration tests for SagaMediator with SqlAlchemySagaStorage (PostgreSQL)."""
+
+import uuid
+from unittest import mock
+
+import pytest
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+import cqrs
+from cqrs import events, SagaMap
+from cqrs.saga.storage.enums import SagaStatus
+from cqrs.saga.storage.sqlalchemy import SqlAlchemySagaStorage
+
+from tests.integration.conftest import _TestContainer
+from tests.integration.test_saga_mediator_memory import (
+    FailingOrderSaga,
+    InventoryReservedEventHandler,
+    OrderContext,
+    OrderSaga,
+    OrderShippedEventHandler,
+    PaymentProcessedEventHandler,
+    ProcessPaymentResponse,
+    ProcessPaymentStep,
+    ReserveInventoryResponse,
+    ReserveInventoryStep,
+    ShipOrderResponse,
+    ShipOrderStep,
+)
+
+
+@pytest.fixture
+def storage(
+    saga_session_factory_postgres: async_sessionmaker[AsyncSession],
+) -> SqlAlchemySagaStorage:
+    """Create SqlAlchemySagaStorage instance (PostgreSQL)."""
+    return SqlAlchemySagaStorage(saga_session_factory_postgres)
+
+
+class TestSagaMediatorSqlAlchemyStoragePostgres:
+    """Integration tests for SagaMediator with SqlAlchemySagaStorage (PostgreSQL)."""
+
+    async def test_saga_mediator_executes_saga_successfully(
+        self,
+        saga_mediator: cqrs.SagaMediator,
+        storage: SqlAlchemySagaStorage,
+    ) -> None:
+        context = OrderContext(order_id="123", user_id="user1", amount=100.0)
+        saga_id = uuid.uuid4()
+        step_results = []
+        async for result in saga_mediator.stream(context, saga_id=saga_id):
+            step_results.append(result)
+        assert len(step_results) == 3
+        assert isinstance(step_results[0].response, ReserveInventoryResponse)
+        assert step_results[0].response.inventory_id == "inv_123"
+        assert isinstance(step_results[1].response, ProcessPaymentResponse)
+        assert isinstance(step_results[2].response, ShipOrderResponse)
+        assert step_results[0].step_type == ReserveInventoryStep
+        assert step_results[1].step_type == ProcessPaymentStep
+        assert step_results[2].step_type == ShipOrderStep
+        status, stored_context, version = await storage.load_saga_state(saga_id)
+        assert status == SagaStatus.COMPLETED
+
+    async def test_saga_mediator_processes_events_from_steps(
+        self,
+        saga_mediator: cqrs.SagaMediator,
+        container: _TestContainer,
+    ) -> None:
+        context = OrderContext(order_id="456", user_id="user2", amount=200.0)
+        step_results = []
+        async for result in saga_mediator.stream(context):
+            step_results.append(result)
+        assert len(step_results) == 3
+        inventory_handler = await container.resolve(InventoryReservedEventHandler)
+        payment_handler = await container.resolve(PaymentProcessedEventHandler)
+        shipping_handler = await container.resolve(OrderShippedEventHandler)
+        assert len(inventory_handler.handled_events) >= 1
+        assert len(payment_handler.handled_events) >= 1
+        assert len(shipping_handler.handled_events) >= 1
+
+    async def test_saga_mediator_emits_events(
+        self,
+        saga_mediator: cqrs.SagaMediator,
+        container: _TestContainer,
+    ) -> None:
+        context = OrderContext(order_id="789", user_id="user3", amount=300.0)
+        async for result in saga_mediator.stream(context):
+            pass
+        inventory_handler = await container.resolve(InventoryReservedEventHandler)
+        payment_handler = await container.resolve(PaymentProcessedEventHandler)
+        shipping_handler = await container.resolve(OrderShippedEventHandler)
+        assert len(inventory_handler.handled_events) >= 1
+        assert len(payment_handler.handled_events) >= 1
+        assert len(shipping_handler.handled_events) >= 1
+
+    async def test_saga_mediator_handles_saga_failure_with_compensation(
+        self,
+        container: _TestContainer,
+        storage: SqlAlchemySagaStorage,
+    ) -> None:
+        def failing_saga_mapper(mapper: SagaMap) -> None:
+            mapper.bind(OrderContext, FailingOrderSaga)
+
+        saga_map = SagaMap()
+        failing_saga_mapper(saga_map)
+        event_map = events.EventMap()
+        event_emitter = events.EventEmitter(
+            event_map=event_map,
+            container=container,  # type: ignore
+            message_broker=mock.AsyncMock(),
+        )
+        failing_mediator = cqrs.SagaMediator(
+            saga_map=saga_map,
+            container=container,  # type: ignore
+            event_emitter=event_emitter,
+            event_map=event_map,
+            storage=storage,
+        )
+        context = OrderContext(order_id="fail_123", user_id="user4", amount=400.0)
+        saga_id = uuid.uuid4()
+        step_results = []
+        with pytest.raises(ValueError, match="Step failed for order fail_123"):
+            async for result in failing_mediator.stream(context, saga_id=saga_id):
+                step_results.append(result)
+        assert len(step_results) >= 1
+        reserve_step = await container.resolve(ReserveInventoryStep)
+        payment_step = await container.resolve(ProcessPaymentStep)
+        assert reserve_step.compensate_called
+        assert payment_step.compensate_called
+        status, _, version = await storage.load_saga_state(saga_id)
+        assert status == SagaStatus.FAILED
+
+    async def test_saga_mediator_with_saga_id_recovery(
+        self,
+        saga_mediator: cqrs.SagaMediator,
+        storage: SqlAlchemySagaStorage,
+    ) -> None:
+        context = OrderContext(order_id="recover_123", user_id="user5", amount=500.0)
+        saga_id = uuid.uuid4()
+        step_results_1 = []
+        async for result in saga_mediator.stream(context, saga_id=saga_id):
+            step_results_1.append(result)
+            if len(step_results_1) == 1:
+                break
+        assert len(step_results_1) == 1
+        assert isinstance(step_results_1[0].response, ReserveInventoryResponse)
+        status, _, version = await storage.load_saga_state(saga_id)
+        assert status == SagaStatus.RUNNING
+        step_results_2 = []
+        async for result in saga_mediator.stream(context, saga_id=saga_id):
+            step_results_2.append(result)
+        assert len(step_results_2) >= 2
+        final_status, _, version = await storage.load_saga_state(saga_id)
+        assert final_status == SagaStatus.COMPLETED
+
+    async def test_saga_mediator_persistence_across_sessions(
+        self,
+        container: _TestContainer,
+        storage: SqlAlchemySagaStorage,
+        saga_session_factory_postgres: async_sessionmaker[AsyncSession],
+    ) -> None:
+        context = OrderContext(order_id="persist_123", user_id="user6", amount=600.0)
+        saga_id = uuid.uuid4()
+
+        def saga_mapper(mapper: SagaMap) -> None:
+            mapper.bind(OrderContext, OrderSaga)
+
+        saga_map = SagaMap()
+        saga_mapper(saga_map)
+        event_map = events.EventMap()
+        event_emitter = events.EventEmitter(
+            event_map=event_map,
+            container=container,  # type: ignore
+            message_broker=mock.AsyncMock(),
+        )
+        mediator = cqrs.SagaMediator(
+            saga_map=saga_map,
+            container=container,  # type: ignore
+            event_emitter=event_emitter,
+            event_map=event_map,
+            storage=storage,
+        )
+        step_results_1 = []
+        async for result in mediator.stream(context, saga_id=saga_id):
+            step_results_1.append(result)
+            if len(step_results_1) == 1:
+                break
+        new_storage = SqlAlchemySagaStorage(saga_session_factory_postgres)
+        status, stored_context, version = await new_storage.load_saga_state(saga_id)
+        assert status == SagaStatus.RUNNING
+        history = await new_storage.get_step_history(saga_id)
+        assert len(history) >= 1
+        assert history[0].step_name == "ReserveInventoryStep"
+
+    async def test_saga_mediator_concurrent_sagas(
+        self,
+        saga_mediator: cqrs.SagaMediator,
+        storage: SqlAlchemySagaStorage,
+    ) -> None:
+        import asyncio
+
+        contexts = [OrderContext(order_id=f"order_{i}", user_id=f"user_{i}", amount=100.0 * i) for i in range(3)]
+        saga_ids = [uuid.uuid4() for _ in range(3)]
+
+        async def execute_saga(context: OrderContext, saga_id: uuid.UUID) -> list:
+            results = []
+            async for result in saga_mediator.stream(context, saga_id=saga_id):
+                results.append(result)
+            return results
+
+        tasks = [execute_saga(context, saga_id) for context, saga_id in zip(contexts, saga_ids)]
+        all_results = await asyncio.gather(*tasks)
+        assert len(all_results) == 3
+        assert all(len(results) == 3 for results in all_results)
+        for saga_id in saga_ids:
+            status, _, version = await storage.load_saga_state(saga_id)
+            assert status == SagaStatus.COMPLETED
+
+    async def test_saga_mediator_concurrent_saga_creation_no_deadlock(
+        self,
+        saga_mediator: cqrs.SagaMediator,
+        storage: SqlAlchemySagaStorage,
+    ) -> None:
+        import asyncio
+
+        n = 10
+        contexts = [OrderContext(order_id=f"order_{i}", user_id=f"user_{i}", amount=100.0 * (i + 1)) for i in range(n)]
+        saga_ids = [uuid.uuid4() for _ in range(n)]
+
+        async def execute_saga(context: OrderContext, saga_id: uuid.UUID) -> list:
+            results = []
+            async for result in saga_mediator.stream(context, saga_id=saga_id):
+                results.append(result)
+            return results
+
+        tasks = [execute_saga(context, saga_id) for context, saga_id in zip(contexts, saga_ids)]
+        all_results = await asyncio.gather(*tasks)
+        assert len(all_results) == n
+        assert all(len(results) == 3 for results in all_results)
+        for saga_id in saga_ids:
+            status, _, _ = await storage.load_saga_state(saga_id)
+            assert status == SagaStatus.COMPLETED
diff --git a/tests/integration/test_saga_storage_memory.py b/tests/integration/test_saga_storage_memory.py
index 652fa79..d38277c 100644
--- a/tests/integration/test_saga_storage_memory.py
+++ b/tests/integration/test_saga_storage_memory.py
@@ -1,5 +1,6 @@
 """Integration tests for MemorySagaStorage."""
 
+import datetime
 import uuid
 
 import pytest
@@ -159,3 +160,327 @@ async def test_compensation_scenario(
         assert history[3].action == "compensate"
         assert history[2].details == "Payment refunded"
         assert history[3].details == "Inventory released"
+
+
+class TestRecoveryMemory:
+    """Integration tests for get_sagas_for_recovery and increment_recovery_attempts (Memory)."""
+
+    # --- get_sagas_for_recovery: positive ---
+
+    async def test_get_sagas_for_recovery_returns_recoverable_sagas(
+        self,
+        storage: MemorySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        """Positive: returns RUNNING and COMPENSATING sagas only; FAILED excluded."""
+        id1, id2, id3 = uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
+        for sid in (id1, id2, id3):
+            await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+        await storage.update_status(id1, SagaStatus.RUNNING)
+        await storage.update_status(id2, SagaStatus.COMPENSATING)
+        await storage.update_status(id3, SagaStatus.FAILED)
+
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert set(ids) == {id1, id2}
+        assert id3 not in ids
+        assert len(ids) == 2
+
+    async def test_get_sagas_for_recovery_respects_limit(
+        self,
+        storage: MemorySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        """Positive: returns at most `limit` saga IDs."""
+        for i in range(5):
+            sid = uuid.uuid4()
+            await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+            await storage.update_status(sid, SagaStatus.RUNNING)
+
+        ids = await storage.get_sagas_for_recovery(limit=2)
+        assert len(ids) == 2
+
+    async def test_get_sagas_for_recovery_respects_max_recovery_attempts(
+        self,
+        storage: MemorySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        """Positive: only returns sagas with recovery_attempts < max_recovery_attempts."""
+        id_low = uuid.uuid4()
+        id_high = uuid.uuid4()
+        await storage.create_saga(saga_id=id_low, name="saga", context=test_context)
+        await storage.create_saga(saga_id=id_high, name="saga", context=test_context)
+        await storage.update_status(id_low, SagaStatus.RUNNING)
+        await storage.update_status(id_high, SagaStatus.RUNNING)
+        # id_high: simulate 5 failed recovery attempts (default max is 5)
+        for _ in range(5):
+            await storage.increment_recovery_attempts(id_high)
+
+        ids = await storage.get_sagas_for_recovery(limit=10, max_recovery_attempts=5)
+        assert id_low in ids
+        assert id_high not in ids
+
+    async def test_get_sagas_for_recovery_ordered_by_updated_at(
+        self,
+        storage: MemorySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        """Positive: result ordered by updated_at ascending (oldest first)."""
+        id1, id2, id3 = uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
+        for sid in (id1, id2, id3):
+            await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+            await storage.update_status(sid, SagaStatus.RUNNING)
+        # touch id2 so its updated_at is latest
+        await storage.update_context(id2, {**test_context, "touched": True})
+
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert len(ids) == 3
+        # id2 was updated last, so should be last in list (oldest first)
+        assert ids[-1] == id2
+
+    async def test_get_sagas_for_recovery_stale_after_excludes_recently_updated(
+        self,
+        storage: MemorySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        """Positive: with stale_after_seconds, recently updated sagas are excluded."""
+        id_recent = uuid.uuid4()
+        await storage.create_saga(saga_id=id_recent, name="saga", context=test_context)
+        await storage.update_status(id_recent, SagaStatus.RUNNING)
+        # No manual change to updated_at: it was just updated
+        ids = await storage.get_sagas_for_recovery(
+            limit=10,
+            stale_after_seconds=60,
+        )
+        assert id_recent not in ids
+
+    async def test_get_sagas_for_recovery_stale_after_includes_old_updated(
+        self,
+        storage: MemorySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        """Positive: with stale_after_seconds, sagas with old updated_at are included."""
+        id_old = uuid.uuid4()
+        await storage.create_saga(saga_id=id_old, name="saga", context=test_context)
+        await storage.update_status(id_old, SagaStatus.RUNNING)
+        storage._sagas[id_old]["updated_at"] = datetime.datetime.now(
+            datetime.timezone.utc,
+        ) - datetime.timedelta(seconds=120)
+        ids = await storage.get_sagas_for_recovery(
+            limit=10,
+            stale_after_seconds=60,
+        )
+        assert id_old in ids
+
+    async def test_get_sagas_for_recovery_without_stale_after_unchanged_behavior(
+        self,
+        storage: MemorySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        """Backward compat: without stale_after_seconds, recently updated sagas are included."""
+        sid = uuid.uuid4()
+        await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+        await storage.update_status(sid, SagaStatus.RUNNING)
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert sid in ids
+
+    async def test_get_sagas_for_recovery_filters_by_saga_name_when_provided(
+        self,
+        storage: MemorySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        """Positive: when saga_name is set, only sagas with that name are returned."""
+        id_foo1 = uuid.uuid4()
+        id_foo2 = uuid.uuid4()
+        id_bar = uuid.uuid4()
+        await storage.create_saga(
+            saga_id=id_foo1,
+            name="OrderSaga",
+            context=test_context,
+        )
+        await storage.create_saga(
+            saga_id=id_foo2,
+            name="OrderSaga",
+            context=test_context,
+        )
+        await storage.create_saga(
+            saga_id=id_bar,
+            name="PaymentSaga",
+            context=test_context,
+        )
+        await storage.update_status(id_foo1, SagaStatus.RUNNING)
+        await storage.update_status(id_foo2, SagaStatus.RUNNING)
+        await storage.update_status(id_bar, SagaStatus.RUNNING)
+
+        ids_all = await storage.get_sagas_for_recovery(limit=10)
+        assert len(ids_all) == 3
+        ids_order = await storage.get_sagas_for_recovery(
+            limit=10,
+            saga_name="OrderSaga",
+        )
+        assert set(ids_order) == {id_foo1, id_foo2}
+        ids_payment = await storage.get_sagas_for_recovery(
+            limit=10,
+            saga_name="PaymentSaga",
+        )
+        assert ids_payment == [id_bar]
+        ids_nonexistent = await storage.get_sagas_for_recovery(
+            limit=10,
+            saga_name="NonExistentSaga",
+        )
+        assert ids_nonexistent == []
+
+    async def test_get_sagas_for_recovery_saga_name_none_returns_all_types(
+        self,
+        storage: MemorySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        """Backward compat: when saga_name is None, all saga types are returned."""
+        id1 = uuid.uuid4()
+        id2 = uuid.uuid4()
+        await storage.create_saga(saga_id=id1, name="SagaA", context=test_context)
+        await storage.create_saga(saga_id=id2, name="SagaB", context=test_context)
+        await storage.update_status(id1, SagaStatus.RUNNING)
+        await storage.update_status(id2, SagaStatus.RUNNING)
+        ids = await storage.get_sagas_for_recovery(limit=10, saga_name=None)
+        assert set(ids) == {id1, id2}
+
+    # --- get_sagas_for_recovery: negative ---
+
+    async def test_get_sagas_for_recovery_empty_when_none_recoverable(
+        self,
+        storage: MemorySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        """Negative: returns empty list when no recoverable sagas."""
+        sid = uuid.uuid4()
+        await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+        # PENDING and COMPLETED are not recoverable
+        await storage.update_status(sid, SagaStatus.COMPLETED)
+
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert ids == []
+
+    async def test_get_sagas_for_recovery_excludes_pending_and_completed(
+        self,
+        storage: MemorySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        """Negative: PENDING and COMPLETED sagas are not returned."""
+        id_pending = uuid.uuid4()
+        id_completed = uuid.uuid4()
+        await storage.create_saga(saga_id=id_pending, name="saga", context=test_context)
+        await storage.create_saga(
+            saga_id=id_completed,
+            name="saga",
+            context=test_context,
+        )
+        await storage.update_status(id_completed, SagaStatus.COMPLETED)
+
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert id_pending not in ids
+        assert id_completed not in ids
+
+    # --- increment_recovery_attempts: positive ---
+
+    async def test_increment_recovery_attempts_increments_counter(
+        self,
+        storage: MemorySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        """Positive: recovery_attempts increases by 1 each call."""
+        await storage.create_saga(saga_id=saga_id, name="saga", context=test_context)
+        await storage.update_status(saga_id, SagaStatus.RUNNING)
+
+        await storage.increment_recovery_attempts(saga_id)
+        _, ctx, ver = await storage.load_saga_state(saga_id)
+        assert storage._sagas[saga_id]["recovery_attempts"] == 1
+
+        await storage.increment_recovery_attempts(saga_id)
+        assert storage._sagas[saga_id]["recovery_attempts"] == 2
+
+    async def test_increment_recovery_attempts_updates_updated_at(
+        self,
+        storage: MemorySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        """Positive: updated_at is set to now."""
+        await storage.create_saga(saga_id=saga_id, name="saga", context=test_context)
+        await storage.update_status(saga_id, SagaStatus.RUNNING)
+        before = storage._sagas[saga_id]["updated_at"]
+
+        await storage.increment_recovery_attempts(saga_id)
+        after = storage._sagas[saga_id]["updated_at"]
+        assert after >= before
+
+    async def test_increment_recovery_attempts_with_new_status(
+        self,
+        storage: MemorySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        """Positive: optional new_status updates saga status."""
+        await storage.create_saga(saga_id=saga_id, name="saga", context=test_context)
+        await storage.update_status(saga_id, SagaStatus.RUNNING)
+
+        await storage.increment_recovery_attempts(saga_id, new_status=SagaStatus.FAILED)
+        status, _, _ = await storage.load_saga_state(saga_id)
+        assert status == SagaStatus.FAILED
+
+    # --- increment_recovery_attempts: negative ---
+
+    async def test_increment_recovery_attempts_raises_when_saga_not_found(
+        self,
+        storage: MemorySagaStorage,
+    ) -> None:
+        """Negative: raises ValueError when saga_id does not exist."""
+        unknown_id = uuid.uuid4()
+        with pytest.raises(ValueError, match="not found"):
+            await storage.increment_recovery_attempts(unknown_id)
+
+    # --- set_recovery_attempts: positive ---
+
+    async def test_set_recovery_attempts_sets_value(
+        self,
+        storage: MemorySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        """Positive: recovery_attempts is set to the given value."""
+        await storage.create_saga(saga_id=saga_id, name="saga", context=test_context)
+        await storage.update_status(saga_id, SagaStatus.RUNNING)
+        await storage.increment_recovery_attempts(saga_id)
+        await storage.increment_recovery_attempts(saga_id)
+        assert storage._sagas[saga_id]["recovery_attempts"] == 2
+
+        await storage.set_recovery_attempts(saga_id, 0)
+        assert storage._sagas[saga_id]["recovery_attempts"] == 0
+
+        await storage.set_recovery_attempts(saga_id, 5)
+        assert storage._sagas[saga_id]["recovery_attempts"] == 5
+
+    async def test_set_recovery_attempts_excludes_from_recovery_when_set_to_max(
+        self,
+        storage: MemorySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        """Positive: setting to max_recovery_attempts excludes saga from get_sagas_for_recovery."""
+        await storage.create_saga(saga_id=saga_id, name="saga", context=test_context)
+        await storage.update_status(saga_id, SagaStatus.RUNNING)
+        await storage.set_recovery_attempts(saga_id, 5)
+
+        ids = await storage.get_sagas_for_recovery(limit=10, max_recovery_attempts=5)
+        assert saga_id not in ids
+
+    # --- set_recovery_attempts: negative ---
+
+    async def test_set_recovery_attempts_raises_when_saga_not_found(
+        self,
+        storage: MemorySagaStorage,
+    ) -> None:
+        """Negative: raises ValueError when saga_id does not exist."""
+        unknown_id = uuid.uuid4()
+        with pytest.raises(ValueError, match="not found"):
+            await storage.set_recovery_attempts(unknown_id, 0)
diff --git a/tests/integration/test_saga_storage_sqlalchemy.py b/tests/integration/test_saga_storage_sqlalchemy.py
deleted file mode 100644
index a4d92c6..0000000
--- a/tests/integration/test_saga_storage_sqlalchemy.py
+++ /dev/null
@@ -1,268 +0,0 @@
-"""Integration tests for SqlAlchemySagaStorage."""
-
-import uuid
-
-import pytest
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
-
-from cqrs.dispatcher.exceptions import SagaConcurrencyError
-from cqrs.saga.storage.enums import SagaStatus, SagaStepStatus
-from cqrs.saga.storage.sqlalchemy import SqlAlchemySagaStorage
-
-# Fixtures init_saga_orm and saga_session_factory are imported from tests/integration/fixtures.py
-
-
-@pytest.fixture
-def storage(
-    saga_session_factory: async_sessionmaker[AsyncSession],
-) -> SqlAlchemySagaStorage:
-    """Create a SqlAlchemySagaStorage instance for each test."""
-    return SqlAlchemySagaStorage(saga_session_factory)
-
-
-@pytest.fixture
-def saga_id() -> uuid.UUID:
-    """Generate a test saga ID."""
-    return uuid.uuid4()
-
-
-@pytest.fixture
-def test_context() -> dict[str, str]:
-    """Test context data."""
-    return {"order_id": "123", "user_id": "user1", "amount": "100.0"}
-
-
-class TestIntegration:
-    """Integration tests for multiple operations."""
-
-    async def test_full_saga_lifecycle(
-        self,
-        storage: SqlAlchemySagaStorage,
-        saga_id: uuid.UUID,
-        test_context: dict[str, str],
-    ) -> None:
-        """Test complete saga lifecycle with all operations."""
-        # Create saga (storage handles transaction commit internally)
-        await storage.create_saga(
-            saga_id=saga_id,
-            name="order_saga",
-            context=test_context,
-        )
-
-        # Update status to running
-        await storage.update_status(saga_id=saga_id, status=SagaStatus.RUNNING)
-
-        # Log step executions
-        await storage.log_step(
-            saga_id=saga_id,
-            step_name="reserve_inventory",
-            action="act",
-            status=SagaStepStatus.STARTED,
-        )
-        await storage.log_step(
-            saga_id=saga_id,
-            step_name="reserve_inventory",
-            action="act",
-            status=SagaStepStatus.COMPLETED,
-        )
-        await storage.log_step(
-            saga_id=saga_id,
-            step_name="process_payment",
-            action="act",
-            status=SagaStepStatus.STARTED,
-        )
-        await storage.log_step(
-            saga_id=saga_id,
-            step_name="process_payment",
-            action="act",
-            status=SagaStepStatus.COMPLETED,
-        )
-
-        # Update context
-        updated_context = {**test_context, "payment_id": "pay_123"}
-        await storage.update_context(saga_id=saga_id, context=updated_context)
-
-        # Update status to completed
-        await storage.update_status(saga_id=saga_id, status=SagaStatus.COMPLETED)
-
-        # Verify final state
-        status, context, version = await storage.load_saga_state(saga_id)
-        assert status == SagaStatus.COMPLETED
-        assert context == updated_context
-        # Initial create(1) + update_status(RUNNING)(2) + update_context(3) + update_status(COMPLETED)(4) = 4
-        assert version == 4
-
-        # Verify history
-        history = await storage.get_step_history(saga_id)
-        assert len(history) == 4
-        assert history[0].step_name == "reserve_inventory"
-        assert history[0].status == SagaStepStatus.STARTED
-        assert history[1].step_name == "reserve_inventory"
-        assert history[1].status == SagaStepStatus.COMPLETED
-        assert history[2].step_name == "process_payment"
-        assert history[2].status == SagaStepStatus.STARTED
-        assert history[3].step_name == "process_payment"
-        assert history[3].status == SagaStepStatus.COMPLETED
-
-    async def test_compensation_scenario(
-        self,
-        storage: SqlAlchemySagaStorage,
-        saga_id: uuid.UUID,
-        test_context: dict[str, str],
-    ) -> None:
-        """Test saga compensation scenario."""
-        await storage.create_saga(
-            saga_id=saga_id,
-            name="order_saga",
-            context=test_context,
-        )
-
-        # Log successful steps
-        await storage.log_step(
-            saga_id=saga_id,
-            step_name="reserve_inventory",
-            action="act",
-            status=SagaStepStatus.COMPLETED,
-        )
-        await storage.log_step(
-            saga_id=saga_id,
-            step_name="process_payment",
-            action="act",
-            status=SagaStepStatus.COMPLETED,
-        )
-
-        # Update status to compensating
-        await storage.update_status(saga_id=saga_id, status=SagaStatus.COMPENSATING)
-
-        # Log compensation steps
-        await storage.log_step(
-            saga_id=saga_id,
-            step_name="process_payment",
-            action="compensate",
-            status=SagaStepStatus.COMPENSATED,
-            details="Payment refunded",
-        )
-        await storage.log_step(
-            saga_id=saga_id,
-            step_name="reserve_inventory",
-            action="compensate",
-            status=SagaStepStatus.COMPENSATED,
-            details="Inventory released",
-        )
-
-        # Update status to failed
-        await storage.update_status(saga_id=saga_id, status=SagaStatus.FAILED)
-
-        # Verify state
-        status, context, version = await storage.load_saga_state(saga_id)
-        assert status == SagaStatus.FAILED
-        # Initial create(1) + update_status(COMPENSATING)(2) + update_status(FAILED)(3) = 3
-        assert version == 3
-
-        # Verify history
-        history = await storage.get_step_history(saga_id)
-        assert len(history) == 4
-        assert history[0].action == "act"
-        assert history[1].action == "act"
-        assert history[2].action == "compensate"
-        assert history[3].action == "compensate"
-        assert history[2].details == "Payment refunded"
-        assert history[3].details == "Inventory released"
-
-    async def test_persistence_across_sessions(
-        self,
-        saga_session_factory: async_sessionmaker[AsyncSession],
-        saga_id: uuid.UUID,
-        test_context: dict[str, str],
-    ) -> None:
-        """Test that saga state persists across different storage instances."""
-        # Create saga with first storage instance
-        storage1 = SqlAlchemySagaStorage(saga_session_factory)
-        await storage1.create_saga(
-            saga_id=saga_id,
-            name="order_saga",
-            context=test_context,
-        )
-        await storage1.update_status(saga_id=saga_id, status=SagaStatus.RUNNING)
-        await storage1.log_step(
-            saga_id=saga_id,
-            step_name="step1",
-            action="act",
-            status=SagaStepStatus.COMPLETED,
-        )
-
-        # Create new storage instance and verify persistence
-        # Note: Since storage now commits internally, data is already persisted
-        storage2 = SqlAlchemySagaStorage(saga_session_factory)
-        status, context, version = await storage2.load_saga_state(saga_id)
-        assert status == SagaStatus.RUNNING
-        assert context == test_context
-        assert version == 2  # create + update_status
-
-        history = await storage2.get_step_history(saga_id)
-        assert len(history) == 1
-        assert history[0].step_name == "step1"
-        assert history[0].status == SagaStepStatus.COMPLETED
-
-    async def test_concurrent_updates(
-        self,
-        storage: SqlAlchemySagaStorage,
-        saga_id: uuid.UUID,
-        test_context: dict[str, str],
-    ) -> None:
-        """Test handling of multiple sequential updates."""
-        await storage.create_saga(
-            saga_id=saga_id,
-            name="order_saga",
-            context=test_context,
-        )
-
-        # Perform multiple updates
-        await storage.update_status(saga_id=saga_id, status=SagaStatus.RUNNING)
-        await storage.update_context(saga_id=saga_id, context={"updated": "context1"})
-        await storage.update_status(saga_id=saga_id, status=SagaStatus.COMPENSATING)
-        await storage.update_context(saga_id=saga_id, context={"updated": "context2"})
-
-        # Verify final state
-        status, context, version = await storage.load_saga_state(saga_id)
-        assert status == SagaStatus.COMPENSATING
-        assert context == {"updated": "context2"}
-        assert version == 5
-
-    async def test_optimistic_locking(
-        self,
-        storage: SqlAlchemySagaStorage,
-        saga_id: uuid.UUID,
-        test_context: dict[str, str],
-    ) -> None:
-        """Test that optimistic locking prevents concurrent modifications."""
-        await storage.create_saga(
-            saga_id=saga_id,
-            name="order_saga",
-            context=test_context,
-        )
-
-        # Get initial state
-        _, _, version = await storage.load_saga_state(saga_id)
-        assert version == 1
-
-        # Successful update with correct version
-        new_context = {**test_context, "updated": True}
-        await storage.update_context(saga_id, new_context, current_version=version)
-
-        # Verify version incremented
-        _, _, new_version = await storage.load_saga_state(saga_id)
-        assert new_version == 2
-
-        # Failed update with old version
-        with pytest.raises(SagaConcurrencyError):
-            await storage.update_context(
-                saga_id,
-                {"stale": True},
-                current_version=version,  # Using old version 1
-            )
-
-        # State should not have changed
-        _, final_context, final_version = await storage.load_saga_state(saga_id)
-        assert final_context == new_context
-        assert final_version == 2
diff --git a/tests/integration/test_saga_storage_sqlalchemy_mysql.py b/tests/integration/test_saga_storage_sqlalchemy_mysql.py
new file mode 100644
index 0000000..a39cb15
--- /dev/null
+++ b/tests/integration/test_saga_storage_sqlalchemy_mysql.py
@@ -0,0 +1,393 @@
+"""Integration tests for SqlAlchemySagaStorage (MySQL).
+Uses DATABASE_DSN_MYSQL from fixtures (pytest-config.ini / env).
+"""
+
+import asyncio
+import uuid
+from collections.abc import AsyncGenerator
+
+import pytest
+from sqlalchemy import delete
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from cqrs.dispatcher.exceptions import SagaConcurrencyError
+from cqrs.saga.storage.enums import SagaStatus, SagaStepStatus
+from cqrs.saga.storage.sqlalchemy import (
+    SagaExecutionModel,
+    SagaLogModel,
+    SqlAlchemySagaStorage,
+)
+
+
+@pytest.fixture
+def storage(
+    saga_session_factory_mysql: async_sessionmaker[AsyncSession],
+) -> SqlAlchemySagaStorage:
+    """SqlAlchemySagaStorage for MySQL (the init_saga_orm_mysql fixture sets up the schema)."""
+    return SqlAlchemySagaStorage(saga_session_factory_mysql)
+
+
+@pytest.fixture
+def saga_id() -> uuid.UUID:
+    return uuid.uuid4()
+
+
+@pytest.fixture
+def test_context() -> dict[str, str]:
+    return {"order_id": "123", "user_id": "user1", "amount": "100.0"}
+
+
+class TestIntegrationMysql:
+    """Integration tests for multiple operations (MySQL)."""
+
+    async def test_full_saga_lifecycle(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="order_saga", context=test_context)
+        await storage.update_status(saga_id=saga_id, status=SagaStatus.RUNNING)
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="reserve_inventory",
+            action="act",
+            status=SagaStepStatus.STARTED,
+        )
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="reserve_inventory",
+            action="act",
+            status=SagaStepStatus.COMPLETED,
+        )
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="process_payment",
+            action="act",
+            status=SagaStepStatus.STARTED,
+        )
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="process_payment",
+            action="act",
+            status=SagaStepStatus.COMPLETED,
+        )
+        updated_context = {**test_context, "payment_id": "pay_123"}
+        await storage.update_context(saga_id=saga_id, context=updated_context)
+        await storage.update_status(saga_id=saga_id, status=SagaStatus.COMPLETED)
+        status, context, version = await storage.load_saga_state(saga_id)
+        assert status == SagaStatus.COMPLETED
+        assert context == updated_context
+        assert version == 4
+        history = await storage.get_step_history(saga_id)
+        assert len(history) == 4
+        assert history[0].step_name == "reserve_inventory"
+        assert history[2].step_name == "process_payment"
+
+    async def test_compensation_scenario(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="order_saga", context=test_context)
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="reserve_inventory",
+            action="act",
+            status=SagaStepStatus.COMPLETED,
+        )
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="process_payment",
+            action="act",
+            status=SagaStepStatus.COMPLETED,
+        )
+        await storage.update_status(saga_id=saga_id, status=SagaStatus.COMPENSATING)
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="process_payment",
+            action="compensate",
+            status=SagaStepStatus.COMPENSATED,
+            details="Payment refunded",
+        )
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="reserve_inventory",
+            action="compensate",
+            status=SagaStepStatus.COMPENSATED,
+            details="Inventory released",
+        )
+        await storage.update_status(saga_id=saga_id, status=SagaStatus.FAILED)
+        status, context, version = await storage.load_saga_state(saga_id)
+        assert status == SagaStatus.FAILED
+        assert version == 3
+        history = await storage.get_step_history(saga_id)
+        assert len(history) == 4
+        assert history[2].action == "compensate"
+        assert history[3].action == "compensate"
+
+    async def test_persistence_across_sessions(
+        self,
+        saga_session_factory_mysql: async_sessionmaker[AsyncSession],
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        storage1 = SqlAlchemySagaStorage(saga_session_factory_mysql)
+        await storage1.create_saga(saga_id=saga_id, name="order_saga", context=test_context)
+        await storage1.update_status(saga_id=saga_id, status=SagaStatus.RUNNING)
+        await storage1.log_step(saga_id=saga_id, step_name="step1", action="act", status=SagaStepStatus.COMPLETED)
+        storage2 = SqlAlchemySagaStorage(saga_session_factory_mysql)
+        status, context, version = await storage2.load_saga_state(saga_id)
+        assert status == SagaStatus.RUNNING
+        assert context == test_context
+        assert version == 2
+        history = await storage2.get_step_history(saga_id)
+        assert len(history) == 1
+        assert history[0].step_name == "step1"
+
+    async def test_concurrent_updates(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="order_saga", context=test_context)
+        await storage.update_status(saga_id=saga_id, status=SagaStatus.RUNNING)
+        await storage.update_context(saga_id=saga_id, context={"updated": "context1"})
+        await storage.update_status(saga_id=saga_id, status=SagaStatus.COMPENSATING)
+        await storage.update_context(saga_id=saga_id, context={"updated": "context2"})
+        status, context, version = await storage.load_saga_state(saga_id)
+        assert status == SagaStatus.COMPENSATING
+        assert context == {"updated": "context2"}
+        assert version == 5
+
+    async def test_optimistic_locking(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="order_saga", context=test_context)
+        _, _, version = await storage.load_saga_state(saga_id)
+        assert version == 1
+        new_context = {**test_context, "updated": True}
+        await storage.update_context(saga_id, new_context, current_version=version)
+        _, _, new_version = await storage.load_saga_state(saga_id)
+        assert new_version == 2
+        with pytest.raises(SagaConcurrencyError):
+            await storage.update_context(saga_id, {"stale": True}, current_version=version)
+        _, final_context, final_version = await storage.load_saga_state(saga_id)
+        assert final_context == new_context
+        assert final_version == 2
+
+
+class TestRecoverySqlAlchemyMysql:
+    """Integration tests for get_sagas_for_recovery and increment_recovery_attempts (MySQL)."""
+
+    @pytest.fixture(autouse=True)
+    async def _clean_saga_tables(
+        self,
+        saga_session_factory_mysql: async_sessionmaker[AsyncSession],
+    ) -> AsyncGenerator[None, None]:
+        async with saga_session_factory_mysql() as session:
+            await session.execute(delete(SagaLogModel))
+            await session.execute(delete(SagaExecutionModel))
+            await session.commit()
+        yield
+
+    async def test_get_sagas_for_recovery_returns_recoverable_sagas(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id1, id2, id3 = uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
+        for sid in (id1, id2, id3):
+            await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+        await storage.update_status(id1, SagaStatus.RUNNING)
+        await storage.update_status(id2, SagaStatus.COMPENSATING)
+        await storage.update_status(id3, SagaStatus.FAILED)
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert set(ids) == {id1, id2}
+        assert id3 not in ids
+
+    async def test_get_sagas_for_recovery_respects_limit(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        for _ in range(5):
+            sid = uuid.uuid4()
+            await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+            await storage.update_status(sid, SagaStatus.RUNNING)
+        ids = await storage.get_sagas_for_recovery(limit=2)
+        assert len(ids) == 2
+
+    async def test_get_sagas_for_recovery_respects_max_recovery_attempts(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id_low, id_high = uuid.uuid4(), uuid.uuid4()
+        await storage.create_saga(saga_id=id_low, name="saga", context=test_context)
+        await storage.create_saga(saga_id=id_high, name="saga", context=test_context)
+        await storage.update_status(id_low, SagaStatus.RUNNING)
+        await storage.update_status(id_high, SagaStatus.RUNNING)
+        for _ in range(5):
+            await storage.increment_recovery_attempts(id_high)
+        ids = await storage.get_sagas_for_recovery(limit=10, max_recovery_attempts=5)
+        assert id_low in ids
+        assert id_high not in ids
+
+    async def test_get_sagas_for_recovery_ordered_by_updated_at(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id1, id2, id3 = uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
+        for sid in (id1, id2, id3):
+            await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+            await storage.update_status(sid, SagaStatus.RUNNING)
+        await asyncio.sleep(1.0)
+        await storage.update_context(id2, {**test_context, "touched": True})
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert len(ids) == 3
+        assert ids[-1] == id2
+
+    async def test_get_sagas_for_recovery_stale_after_excludes_recently_updated(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id_recent = uuid.uuid4()
+        await storage.create_saga(saga_id=id_recent, name="saga", context=test_context)
+        await storage.update_status(id_recent, SagaStatus.RUNNING)
+        ids = await storage.get_sagas_for_recovery(limit=10, stale_after_seconds=999999)
+        assert id_recent not in ids
+
+    async def test_get_sagas_for_recovery_without_stale_after_unchanged_behavior(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        sid = uuid.uuid4()
+        await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+        await storage.update_status(sid, SagaStatus.RUNNING)
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert sid in ids
+
+    async def test_get_sagas_for_recovery_filters_by_saga_name_when_provided(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id_foo1, id_foo2, id_bar = uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
+        await storage.create_saga(saga_id=id_foo1, name="OrderSaga", context=test_context)
+        await storage.create_saga(saga_id=id_foo2, name="OrderSaga", context=test_context)
+        await storage.create_saga(saga_id=id_bar, name="PaymentSaga", context=test_context)
+        await storage.update_status(id_foo1, SagaStatus.RUNNING)
+        await storage.update_status(id_foo2, SagaStatus.RUNNING)
+        await storage.update_status(id_bar, SagaStatus.RUNNING)
+        ids_order = await storage.get_sagas_for_recovery(limit=10, saga_name="OrderSaga")
+        assert set(ids_order) == {id_foo1, id_foo2}
+        ids_payment = await storage.get_sagas_for_recovery(limit=10, saga_name="PaymentSaga")
+        assert ids_payment == [id_bar]
+        ids_none = await storage.get_sagas_for_recovery(limit=10, saga_name="NonExistentSaga")
+        assert ids_none == []
+
+    async def test_get_sagas_for_recovery_saga_name_none_returns_all_types(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id1, id2 = uuid.uuid4(), uuid.uuid4()
+        await storage.create_saga(saga_id=id1, name="SagaA", context=test_context)
+        await storage.create_saga(saga_id=id2, name="SagaB", context=test_context)
+        await storage.update_status(id1, SagaStatus.RUNNING)
+        await storage.update_status(id2, SagaStatus.RUNNING)
+        ids = await storage.get_sagas_for_recovery(limit=10, saga_name=None)
+        assert set(ids) == {id1, id2}
+
+    async def test_get_sagas_for_recovery_empty_when_none_recoverable(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        sid = uuid.uuid4()
+        await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+        await storage.update_status(sid, SagaStatus.COMPLETED)
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert ids == []
+
+    async def test_get_sagas_for_recovery_excludes_pending_and_completed(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id_pending, id_completed = uuid.uuid4(), uuid.uuid4()
+        await storage.create_saga(saga_id=id_pending, name="saga", context=test_context)
+        await storage.create_saga(saga_id=id_completed, name="saga", context=test_context)
+        await storage.update_status(id_completed, SagaStatus.COMPLETED)
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert id_pending not in ids
+        assert id_completed not in ids
+
+    async def test_increment_recovery_attempts_increments_counter(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="saga", context=test_context)
+        await storage.update_status(saga_id, SagaStatus.RUNNING)
+        ids_before = await storage.get_sagas_for_recovery(limit=10, max_recovery_attempts=5)
+        assert saga_id in ids_before
+        for _ in range(5):
+            await storage.increment_recovery_attempts(saga_id)
+        ids_after = await storage.get_sagas_for_recovery(limit=10, max_recovery_attempts=5)
+        assert saga_id not in ids_after
+
+    async def test_increment_recovery_attempts_with_new_status(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="saga", context=test_context)
+        await storage.update_status(saga_id, SagaStatus.RUNNING)
+        await storage.increment_recovery_attempts(saga_id, new_status=SagaStatus.FAILED)
+        status, _, _ = await storage.load_saga_state(saga_id)
+        assert status == SagaStatus.FAILED
+
+    async def test_increment_recovery_attempts_raises_when_saga_not_found(
+        self,
+        storage: SqlAlchemySagaStorage,
+    ) -> None:
+        unknown_id = uuid.uuid4()
+        with pytest.raises(ValueError, match="not found"):
+            await storage.increment_recovery_attempts(unknown_id)
+
+    async def test_set_recovery_attempts_sets_value(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="saga", context=test_context)
+        await storage.update_status(saga_id, SagaStatus.RUNNING)
+        await storage.increment_recovery_attempts(saga_id)
+        await storage.increment_recovery_attempts(saga_id)
+        await storage.set_recovery_attempts(saga_id, 0)
+        ids_reset = await storage.get_sagas_for_recovery(limit=10, max_recovery_attempts=5)
+        assert saga_id in ids_reset
+        await storage.set_recovery_attempts(saga_id, 5)
+        ids_max = await storage.get_sagas_for_recovery(limit=10, max_recovery_attempts=5)
+        assert saga_id not in ids_max
+
+    async def test_set_recovery_attempts_raises_when_saga_not_found(
+        self,
+        storage: SqlAlchemySagaStorage,
+    ) -> None:
+        unknown_id = uuid.uuid4()
+        with pytest.raises(ValueError, match="not found"):
+            await storage.set_recovery_attempts(unknown_id, 0)
diff --git a/tests/integration/test_saga_storage_sqlalchemy_postgres.py b/tests/integration/test_saga_storage_sqlalchemy_postgres.py
new file mode 100644
index 0000000..24ac125
--- /dev/null
+++ b/tests/integration/test_saga_storage_sqlalchemy_postgres.py
@@ -0,0 +1,398 @@
+"""Integration tests for SqlAlchemySagaStorage (PostgreSQL).
+Uses DATABASE_DSN_POSTGRESQL from fixtures (pytest-config.ini / env).
+"""
+
+import uuid
+from collections.abc import AsyncGenerator
+from datetime import datetime, timedelta, timezone
+
+import pytest
+from sqlalchemy import delete, update
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from cqrs.dispatcher.exceptions import SagaConcurrencyError
+from cqrs.saga.storage.enums import SagaStatus, SagaStepStatus
+from cqrs.saga.storage.sqlalchemy import (
+    SagaExecutionModel,
+    SagaLogModel,
+    SqlAlchemySagaStorage,
+)
+
+
+@pytest.fixture
+def storage(
+    saga_session_factory_postgres: async_sessionmaker[AsyncSession],
+) -> SqlAlchemySagaStorage:
+    """SqlAlchemySagaStorage for PostgreSQL (the init_saga_orm_postgres fixture sets up the schema)."""
+    return SqlAlchemySagaStorage(saga_session_factory_postgres)
+
+
+@pytest.fixture
+def saga_id() -> uuid.UUID:
+    return uuid.uuid4()
+
+
+@pytest.fixture
+def test_context() -> dict[str, str]:
+    return {"order_id": "123", "user_id": "user1", "amount": "100.0"}
+
+
+class TestIntegrationPostgres:
+    """Integration tests for multiple operations (PostgreSQL)."""
+
+    async def test_full_saga_lifecycle(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="order_saga", context=test_context)
+        await storage.update_status(saga_id=saga_id, status=SagaStatus.RUNNING)
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="reserve_inventory",
+            action="act",
+            status=SagaStepStatus.STARTED,
+        )
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="reserve_inventory",
+            action="act",
+            status=SagaStepStatus.COMPLETED,
+        )
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="process_payment",
+            action="act",
+            status=SagaStepStatus.STARTED,
+        )
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="process_payment",
+            action="act",
+            status=SagaStepStatus.COMPLETED,
+        )
+        updated_context = {**test_context, "payment_id": "pay_123"}
+        await storage.update_context(saga_id=saga_id, context=updated_context)
+        await storage.update_status(saga_id=saga_id, status=SagaStatus.COMPLETED)
+        status, context, version = await storage.load_saga_state(saga_id)
+        assert status == SagaStatus.COMPLETED
+        assert context == updated_context
+        assert version == 4
+        history = await storage.get_step_history(saga_id)
+        assert len(history) == 4
+        assert history[0].step_name == "reserve_inventory"
+        assert history[2].step_name == "process_payment"
+
+    async def test_compensation_scenario(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="order_saga", context=test_context)
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="reserve_inventory",
+            action="act",
+            status=SagaStepStatus.COMPLETED,
+        )
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="process_payment",
+            action="act",
+            status=SagaStepStatus.COMPLETED,
+        )
+        await storage.update_status(saga_id=saga_id, status=SagaStatus.COMPENSATING)
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="process_payment",
+            action="compensate",
+            status=SagaStepStatus.COMPENSATED,
+            details="Payment refunded",
+        )
+        await storage.log_step(
+            saga_id=saga_id,
+            step_name="reserve_inventory",
+            action="compensate",
+            status=SagaStepStatus.COMPENSATED,
+            details="Inventory released",
+        )
+        await storage.update_status(saga_id=saga_id, status=SagaStatus.FAILED)
+        status, context, version = await storage.load_saga_state(saga_id)
+        assert status == SagaStatus.FAILED
+        assert version == 3
+        history = await storage.get_step_history(saga_id)
+        assert len(history) == 4
+        assert history[2].action == "compensate"
+        assert history[3].action == "compensate"
+
+    async def test_persistence_across_sessions(
+        self,
+        saga_session_factory_postgres: async_sessionmaker[AsyncSession],
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        storage1 = SqlAlchemySagaStorage(saga_session_factory_postgres)
+        await storage1.create_saga(saga_id=saga_id, name="order_saga", context=test_context)
+        await storage1.update_status(saga_id=saga_id, status=SagaStatus.RUNNING)
+        await storage1.log_step(saga_id=saga_id, step_name="step1", action="act", status=SagaStepStatus.COMPLETED)
+        storage2 = SqlAlchemySagaStorage(saga_session_factory_postgres)
+        status, context, version = await storage2.load_saga_state(saga_id)
+        assert status == SagaStatus.RUNNING
+        assert context == test_context
+        assert version == 2
+        history = await storage2.get_step_history(saga_id)
+        assert len(history) == 1
+        assert history[0].step_name == "step1"
+
+    async def test_concurrent_updates(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="order_saga", context=test_context)
+        await storage.update_status(saga_id=saga_id, status=SagaStatus.RUNNING)
+        await storage.update_context(saga_id=saga_id, context={"updated": "context1"})
+        await storage.update_status(saga_id=saga_id, status=SagaStatus.COMPENSATING)
+        await storage.update_context(saga_id=saga_id, context={"updated": "context2"})
+        status, context, version = await storage.load_saga_state(saga_id)
+        assert status == SagaStatus.COMPENSATING
+        assert context == {"updated": "context2"}
+        assert version == 5
+
+    async def test_optimistic_locking(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="order_saga", context=test_context)
+        _, _, version = await storage.load_saga_state(saga_id)
+        assert version == 1
+        new_context = {**test_context, "updated": True}
+        await storage.update_context(saga_id, new_context, current_version=version)
+        _, _, new_version = await storage.load_saga_state(saga_id)
+        assert new_version == 2
+        with pytest.raises(SagaConcurrencyError):
+            await storage.update_context(saga_id, {"stale": True}, current_version=version)
+        _, final_context, final_version = await storage.load_saga_state(saga_id)
+        assert final_context == new_context
+        assert final_version == 2
+
+
+class TestRecoverySqlAlchemyPostgres:
+    """Integration tests for get_sagas_for_recovery and increment_recovery_attempts (PostgreSQL)."""
+
+    @pytest.fixture(autouse=True)
+    async def _clean_saga_tables(
+        self,
+        saga_session_factory_postgres: async_sessionmaker[AsyncSession],
+    ) -> AsyncGenerator[None, None]:
+        async with saga_session_factory_postgres() as session:
+            await session.execute(delete(SagaLogModel))
+            await session.execute(delete(SagaExecutionModel))
+            await session.commit()
+        yield
+
+    async def test_get_sagas_for_recovery_returns_recoverable_sagas(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id1, id2, id3 = uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
+        for sid in (id1, id2, id3):
+            await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+        await storage.update_status(id1, SagaStatus.RUNNING)
+        await storage.update_status(id2, SagaStatus.COMPENSATING)
+        await storage.update_status(id3, SagaStatus.FAILED)
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert set(ids) == {id1, id2}
+        assert id3 not in ids
+
+    async def test_get_sagas_for_recovery_respects_limit(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        for _ in range(5):
+            sid = uuid.uuid4()
+            await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+            await storage.update_status(sid, SagaStatus.RUNNING)
+        ids = await storage.get_sagas_for_recovery(limit=2)
+        assert len(ids) == 2
+
+    async def test_get_sagas_for_recovery_respects_max_recovery_attempts(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id_low, id_high = uuid.uuid4(), uuid.uuid4()
+        await storage.create_saga(saga_id=id_low, name="saga", context=test_context)
+        await storage.create_saga(saga_id=id_high, name="saga", context=test_context)
+        await storage.update_status(id_low, SagaStatus.RUNNING)
+        await storage.update_status(id_high, SagaStatus.RUNNING)
+        for _ in range(5):
+            await storage.increment_recovery_attempts(id_high)
+        ids = await storage.get_sagas_for_recovery(limit=10, max_recovery_attempts=5)
+        assert id_low in ids
+        assert id_high not in ids
+
+    async def test_get_sagas_for_recovery_ordered_by_updated_at(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id1, id2, id3 = uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
+        for sid in (id1, id2, id3):
+            await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+            await storage.update_status(sid, SagaStatus.RUNNING)
+        # Set id2's updated_at to a later time so ordering is deterministic (no sleep).
+        later = datetime.now(timezone.utc) + timedelta(seconds=10)
+        async with storage.session_factory() as session:
+            await session.execute(
+                update(SagaExecutionModel).where(SagaExecutionModel.id == id2).values(updated_at=later),
+            )
+            await session.commit()
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert len(ids) == 3
+        assert ids[-1] == id2
+
+    async def test_get_sagas_for_recovery_stale_after_excludes_recently_updated(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id_recent = uuid.uuid4()
+        await storage.create_saga(saga_id=id_recent, name="saga", context=test_context)
+        await storage.update_status(id_recent, SagaStatus.RUNNING)
+        ids = await storage.get_sagas_for_recovery(limit=10, stale_after_seconds=999999)
+        assert id_recent not in ids
+
+    async def test_get_sagas_for_recovery_without_stale_after_unchanged_behavior(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        sid = uuid.uuid4()
+        await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+        await storage.update_status(sid, SagaStatus.RUNNING)
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert sid in ids
+
+    async def test_get_sagas_for_recovery_filters_by_saga_name_when_provided(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id_foo1, id_foo2, id_bar = uuid.uuid4(), uuid.uuid4(), uuid.uuid4()
+        await storage.create_saga(saga_id=id_foo1, name="OrderSaga", context=test_context)
+        await storage.create_saga(saga_id=id_foo2, name="OrderSaga", context=test_context)
+        await storage.create_saga(saga_id=id_bar, name="PaymentSaga", context=test_context)
+        await storage.update_status(id_foo1, SagaStatus.RUNNING)
+        await storage.update_status(id_foo2, SagaStatus.RUNNING)
+        await storage.update_status(id_bar, SagaStatus.RUNNING)
+        ids_order = await storage.get_sagas_for_recovery(limit=10, saga_name="OrderSaga")
+        assert set(ids_order) == {id_foo1, id_foo2}
+        ids_payment = await storage.get_sagas_for_recovery(limit=10, saga_name="PaymentSaga")
+        assert ids_payment == [id_bar]
+        ids_none = await storage.get_sagas_for_recovery(limit=10, saga_name="NonExistentSaga")
+        assert ids_none == []
+
+    async def test_get_sagas_for_recovery_saga_name_none_returns_all_types(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id1, id2 = uuid.uuid4(), uuid.uuid4()
+        await storage.create_saga(saga_id=id1, name="SagaA", context=test_context)
+        await storage.create_saga(saga_id=id2, name="SagaB", context=test_context)
+        await storage.update_status(id1, SagaStatus.RUNNING)
+        await storage.update_status(id2, SagaStatus.RUNNING)
+        ids = await storage.get_sagas_for_recovery(limit=10, saga_name=None)
+        assert set(ids) == {id1, id2}
+
+    async def test_get_sagas_for_recovery_empty_when_none_recoverable(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        sid = uuid.uuid4()
+        await storage.create_saga(saga_id=sid, name="saga", context=test_context)
+        await storage.update_status(sid, SagaStatus.COMPLETED)
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert ids == []
+
+    async def test_get_sagas_for_recovery_excludes_pending_and_completed(
+        self,
+        storage: SqlAlchemySagaStorage,
+        test_context: dict[str, str],
+    ) -> None:
+        id_pending, id_completed = uuid.uuid4(), uuid.uuid4()
+        await storage.create_saga(saga_id=id_pending, name="saga", context=test_context)
+        await storage.create_saga(saga_id=id_completed, name="saga", context=test_context)
+        await storage.update_status(id_completed, SagaStatus.COMPLETED)
+        ids = await storage.get_sagas_for_recovery(limit=10)
+        assert id_pending not in ids
+        assert id_completed not in ids
+
+    async def test_increment_recovery_attempts_increments_counter(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="saga", context=test_context)
+        await storage.update_status(saga_id, SagaStatus.RUNNING)
+        ids_before = await storage.get_sagas_for_recovery(limit=10, max_recovery_attempts=5)
+        assert saga_id in ids_before
+        for _ in range(5):
+            await storage.increment_recovery_attempts(saga_id)
+        ids_after = await storage.get_sagas_for_recovery(limit=10, max_recovery_attempts=5)
+        assert saga_id not in ids_after
+
+    async def test_increment_recovery_attempts_with_new_status(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="saga", context=test_context)
+        await storage.update_status(saga_id, SagaStatus.RUNNING)
+        await storage.increment_recovery_attempts(saga_id, new_status=SagaStatus.FAILED)
+        status, _, _ = await storage.load_saga_state(saga_id)
+        assert status == SagaStatus.FAILED
+
+    async def test_increment_recovery_attempts_raises_when_saga_not_found(
+        self,
+        storage: SqlAlchemySagaStorage,
+    ) -> None:
+        unknown_id = uuid.uuid4()
+        with pytest.raises(ValueError, match="not found"):
+            await storage.increment_recovery_attempts(unknown_id)
+
+    async def test_set_recovery_attempts_sets_value(
+        self,
+        storage: SqlAlchemySagaStorage,
+        saga_id: uuid.UUID,
+        test_context: dict[str, str],
+    ) -> None:
+        await storage.create_saga(saga_id=saga_id, name="saga", context=test_context)
+        await storage.update_status(saga_id, SagaStatus.RUNNING)
+        await storage.increment_recovery_attempts(saga_id)
+        await storage.increment_recovery_attempts(saga_id)
+        await storage.set_recovery_attempts(saga_id, 0)
+        ids_reset = await storage.get_sagas_for_recovery(limit=10, max_recovery_attempts=5)
+        assert saga_id in ids_reset
+        await storage.set_recovery_attempts(saga_id, 5)
+        ids_max = await storage.get_sagas_for_recovery(limit=10, max_recovery_attempts=5)
+        assert saga_id not in ids_max
+
+    async def test_set_recovery_attempts_raises_when_saga_not_found(
+        self,
+        storage: SqlAlchemySagaStorage,
+    ) -> None:
+        unknown_id = uuid.uuid4()
+        with pytest.raises(ValueError, match="not found"):
+            await storage.set_recovery_attempts(unknown_id, 0)
diff --git a/tests/integration/test_streaming_mediator.py b/tests/integration/test_streaming_mediator.py
index ef07d97..66ecb6f 100644
--- a/tests/integration/test_streaming_mediator.py
+++ b/tests/integration/test_streaming_mediator.py
@@ -1,3 +1,4 @@
+import asyncio
 import typing
 
 import pydantic
@@ -27,13 +28,13 @@ def __init__(self) -> None:
         self._processed_count = 0
 
     @property
-    def events(self) -> typing.List[events.Event]:
+    def events(self) -> typing.Sequence[events.IEvent]:
         return self._events.copy()
 
     def clear_events(self) -> None:
         self._events.clear()
 
-    async def handle(  # type: ignore
+    async def handle(
         self,
         request: ProcessItemsCommand,
     ) -> typing.AsyncIterator[ProcessItemResult]:
@@ -109,6 +110,9 @@ async def test_streaming_mediator_integration(
     async for result in mediator.stream(command):
         results.append(result)
 
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert handler
     assert handler.called
 
@@ -140,8 +144,13 @@ async def test_streaming_mediator_events_emitted_after_each_yield(
     results = []
     async for result in mediator.stream(command):
         results.append(result)
+        # Wait a bit for background task to complete
+        await asyncio.sleep(0.05)
         call_counts.append(kafka_producer.produce.call_count)
 
+    # Wait for final background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert call_counts[0] == 1
     assert call_counts[1] == 2
 
@@ -184,6 +193,9 @@ async def test_streaming_mediator_single_item(
     async for result in mediator.stream(command):
         results.append(result)
 
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert handler
     assert handler.called
     assert len(results) == 1
diff --git a/tests/pytest-config.ini b/tests/pytest-config.ini
index e35a5fc..fc3e329 100644
--- a/tests/pytest-config.ini
+++ b/tests/pytest-config.ini
@@ -1,7 +1,9 @@
 [pytest]
 asyncio_mode = auto
-asyncio_default_fixture_loop_scope = session
+norecursedirs = benchmarks
 env =
     DATABASE_DSN=mysql+asyncmy://cqrs:cqrs@localhost:3307/test_cqrs
+    DATABASE_DSN_MYSQL=mysql+asyncmy://cqrs:cqrs@localhost:3307/test_cqrs
+    DATABASE_DSN_POSTGRESQL=postgresql+asyncpg://cqrs:cqrs@localhost:5433/cqrs
 filterwarnings =
     ignore::DeprecationWarning:aio_pika.*
diff --git a/tests/unit/test_bootstrap_streaming_dependency_injector.py b/tests/unit/test_bootstrap_streaming_dependency_injector.py
new file mode 100644
index 0000000..16e2e19
--- /dev/null
+++ b/tests/unit/test_bootstrap_streaming_dependency_injector.py
@@ -0,0 +1,493 @@
+"""
+Tests for bootstrap_streaming with DependencyInjectorCQRSContainer integration.
+
+This test suite validates that bootstrap_streaming correctly works with
+DependencyInjectorCQRSContainer, ensuring that:
+- Handlers can be resolved from dependency-injector containers
+- Dependencies are properly injected into handlers
+- Events are processed correctly
+- Streaming functionality works as expected
+"""
+
+import asyncio
+import typing
+from abc import ABC, abstractmethod
+
+import cqrs
+import pydantic
+from cqrs.container.dependency_injector import DependencyInjectorCQRSContainer
+from cqrs.events import DomainEvent, Event, EventHandler
+from cqrs.events.event import IEvent
+from cqrs.message_brokers import devnull
+from cqrs.requests import bootstrap
+from cqrs.requests.request import Request
+from cqrs.requests.request_handler import StreamingRequestHandler
+from cqrs.response import Response
+from dependency_injector import containers, providers
+
+
+# ============================================================================
+# Test Models and Commands
+# ============================================================================
+
+
+class ProcessItemsCommand(Request):
+    item_ids: list[str] = pydantic.Field()
+
+
+class ProcessItemResult(Response):
+    item_id: str = pydantic.Field()
+    status: str = pydantic.Field()
+
+
+class ItemProcessedDomainEvent(DomainEvent, frozen=True):
+    item_id: str = pydantic.Field()
+
+
+# ============================================================================
+# Dependencies
+# ============================================================================
+
+
+class IItemService(ABC):
+    @abstractmethod
+    async def process_item(self, item_id: str) -> str:
+        pass
+
+
+class ItemService(IItemService):
+    def __init__(self) -> None:
+        self.processed_items: list[str] = []
+
+    async def process_item(self, item_id: str) -> str:
+        self.processed_items.append(item_id)
+        return f"Processed {item_id}"
+
+
+class IEventLogger(ABC):
+    @abstractmethod
+    async def log_event(self, event: DomainEvent) -> None:
+        pass
+
+
+class EventLogger(IEventLogger):
+    def __init__(self) -> None:
+        self.logged_events: list[DomainEvent] = []
+
+    async def log_event(self, event: DomainEvent) -> None:
+        self.logged_events.append(event)
+
+
+# ============================================================================
+# Handlers
+# ============================================================================
+
+
+class StreamingItemHandler(
+    StreamingRequestHandler[ProcessItemsCommand, ProcessItemResult],
+):
+    def __init__(self, item_service: IItemService) -> None:
+        self.item_service = item_service
+        self.called = False
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> typing.Sequence[IEvent]:
+        return self._events.copy()
+
+    def clear_events(self) -> None:
+        self._events.clear()
+
+    async def handle(
+        self,
+        request: ProcessItemsCommand,
+    ) -> typing.AsyncIterator[ProcessItemResult]:
+        self.called = True
+        for item_id in request.item_ids:
+            await self.item_service.process_item(item_id)
+            result = ProcessItemResult(item_id=item_id, status="processed")
+            yield result
+
+
+class ItemProcessedEventHandler(EventHandler[ItemProcessedDomainEvent]):
+    def __init__(self, event_logger: IEventLogger) -> None:
+        self.event_logger = event_logger
+        self.processed_events: list[ItemProcessedDomainEvent] = []
+
+    async def handle(self, event: ItemProcessedDomainEvent) -> None:
+        await self.event_logger.log_event(event)
+        self.processed_events.append(event)
+
+
+# ============================================================================
+# Dependency Injector Containers
+# ============================================================================
+
+
+class ApplicationContainer(containers.DeclarativeContainer):
+    # Services
+    item_service = providers.Singleton(ItemService)
+    event_logger = providers.Singleton(EventLogger)
+
+    # Handlers
+    streaming_item_handler = providers.Factory(
+        StreamingItemHandler,
+        item_service=item_service,
+    )
+    item_processed_event_handler = providers.Factory(
+        ItemProcessedEventHandler,
+        event_logger=event_logger,
+    )
+
+
+# ============================================================================
+# Tests
+# ============================================================================
+
+
+class TestBootstrapStreamingWithDependencyInjector:
+    """Test suite for bootstrap_streaming with DependencyInjectorCQRSContainer."""
+
+    def setup_di_container(self) -> DependencyInjectorCQRSContainer:
+        """Set up the dependency injector container for the CQRS framework."""
+        container = ApplicationContainer()
+        cqrs_container = DependencyInjectorCQRSContainer()
+        cqrs_container.attach_external_container(container)
+        return cqrs_container
+
+    def commands_mapper(self, mapper: cqrs.RequestMap) -> None:
+        """Maps commands to handlers."""
+        mapper.bind(ProcessItemsCommand, StreamingItemHandler)
+
+    def domain_events_mapper(self, mapper: cqrs.EventMap) -> None:
+        """Maps domain events to handlers."""
+        mapper.bind(ItemProcessedDomainEvent, ItemProcessedEventHandler)
+
+    async def test_bootstrap_streaming_with_dependency_injector_container(
+        self,
+    ) -> None:
+        """
+        Test that bootstrap_streaming works with DependencyInjectorCQRSContainer.
+
+        Validates that:
+        - bootstrap_streaming accepts DependencyInjectorCQRSContainer
+        - Handlers are resolved from the container
+        - Dependencies are injected correctly
+        - Streaming works as expected
+        """
+        cqrs_container = self.setup_di_container()
+
+        mediator = bootstrap.bootstrap_streaming(
+            di_container=cqrs_container,
+            commands_mapper=self.commands_mapper,
+            message_broker=devnull.DevnullMessageBroker(),
+        )
+
+        request = ProcessItemsCommand(item_ids=["item1", "item2", "item3"])
+        results = []
+        async for result in mediator.stream(request):
+            results.append(result)
+
+        # Wait for background tasks to complete
+        await asyncio.sleep(0.1)
+
+        assert len(results) == 3
+        assert results[0].item_id == "item1"
+        assert results[1].item_id == "item2"
+        assert results[2].item_id == "item3"
+
+        # Verify handler was called and dependencies were injected
+        # Check through item_service (singleton) that handler was executed
+        item_service = await cqrs_container.resolve(ItemService)
+        assert len(item_service.processed_items) == 3
+        assert "item1" in item_service.processed_items
+        assert "item2" in item_service.processed_items
+        assert "item3" in item_service.processed_items
+
+        # Verify handler can be resolved and dependencies are injected correctly
+        handler = await cqrs_container.resolve(StreamingItemHandler)
+        assert handler.item_service is not None
+        assert isinstance(handler.item_service, ItemService)
+        # Verify that handler uses the same service instance (singleton)
+        assert handler.item_service is item_service
+
+    async def test_bootstrap_streaming_with_events_and_dependency_injection(
+        self,
+    ) -> None:
+        """
+        Test that bootstrap_streaming processes events with dependency injection.
+
+        Validates that:
+        - Event handlers are resolved from the container
+        - Event handler dependencies are injected correctly
+        - Events are processed after command execution
+        """
+
+        # Create a handler that emits events
+        class EventEmittingHandler(
+            StreamingRequestHandler[ProcessItemsCommand, ProcessItemResult],
+        ):
+            def __init__(self, item_service: IItemService) -> None:
+                self.item_service = item_service
+                self._events: list[Event] = []
+
+            @property
+            def events(self) -> typing.Sequence[IEvent]:
+                return self._events.copy()
+
+            def clear_events(self) -> None:
+                self._events.clear()
+
+            async def handle(
+                self,
+                request: ProcessItemsCommand,
+            ) -> typing.AsyncIterator[ProcessItemResult]:
+                for item_id in request.item_ids:
+                    await self.item_service.process_item(item_id)
+                    result = ProcessItemResult(item_id=item_id, status="processed")
+                    # Emit domain event
+                    event = ItemProcessedDomainEvent(item_id=item_id)
+                    self._events.append(event)
+                    yield result
+
+        # Create a container with the handler registered
+        class EventEmittingContainer(containers.DeclarativeContainer):
+            item_service = providers.Singleton(ItemService)
+            event_logger = providers.Singleton(EventLogger)
+            event_emitting_handler = providers.Factory(
+                EventEmittingHandler,
+                item_service=item_service,
+            )
+            item_processed_event_handler = providers.Factory(
+                ItemProcessedEventHandler,
+                event_logger=event_logger,
+            )
+
+        container = EventEmittingContainer()
+        cqrs_container = DependencyInjectorCQRSContainer()
+        cqrs_container.attach_external_container(container)
+
+        # Update mapper
+        def commands_mapper_override(mapper: cqrs.RequestMap) -> None:
+            mapper.bind(ProcessItemsCommand, EventEmittingHandler)
+
+        mediator = bootstrap.bootstrap_streaming(
+            di_container=cqrs_container,
+            commands_mapper=commands_mapper_override,
+            domain_events_mapper=self.domain_events_mapper,
+            message_broker=devnull.DevnullMessageBroker(),
+        )
+
+        request = ProcessItemsCommand(item_ids=["item1", "item2"])
+        results = []
+        async for result in mediator.stream(request):
+            results.append(result)
+
+        # Wait for background tasks to complete
+        await asyncio.sleep(0.2)
+
+        assert len(results) == 2
+
+        # Verify event handler was called and dependencies were injected
+        # Since ItemProcessedEventHandler is a Factory, we get a new instance each time
+        # So we check through event_logger (Singleton) that events were processed
+        event_logger = await cqrs_container.resolve(EventLogger)
+        assert len(event_logger.logged_events) == 2
+        assert isinstance(event_logger.logged_events[0], ItemProcessedDomainEvent)
+        assert isinstance(event_logger.logged_events[1], ItemProcessedDomainEvent)
+        assert event_logger.logged_events[0].item_id == "item1"
+        assert event_logger.logged_events[1].item_id == "item2"
+
+        # Verify that event handler can be resolved and dependencies are injected
+        event_handler = await cqrs_container.resolve(ItemProcessedEventHandler)
+        assert event_handler.event_logger is not None
+        assert isinstance(event_handler.event_logger, EventLogger)
+        # Verify that handler uses the same logger instance (singleton)
+        assert event_handler.event_logger is event_logger
+
+    async def test_bootstrap_streaming_with_parallel_event_handling(
+        self,
+    ) -> None:
+        """
+        Test that bootstrap_streaming processes events in parallel with dependency injection.
+
+        Validates that:
+        - Multiple event handlers can run in parallel
+        - Each handler instance gets its own dependencies
+        - Parallel processing works correctly with dependency injection
+        """
+
+        # Create a handler that emits events
+        class EventEmittingHandler(
+            StreamingRequestHandler[ProcessItemsCommand, ProcessItemResult],
+        ):
+            def __init__(self, item_service: IItemService) -> None:
+                self.item_service = item_service
+                self._events: list[Event] = []
+
+            @property
+            def events(self) -> typing.Sequence[IEvent]:
+                return self._events.copy()
+
+            def clear_events(self) -> None:
+                self._events.clear()
+
+            async def handle(
+                self,
+                request: ProcessItemsCommand,
+            ) -> typing.AsyncIterator[ProcessItemResult]:
+                for item_id in request.item_ids:
+                    await self.item_service.process_item(item_id)
+                    result = ProcessItemResult(item_id=item_id, status="processed")
+                    # Emit domain event
+                    event = ItemProcessedDomainEvent(item_id=item_id)
+                    self._events.append(event)
+                    yield result
+
+        # Create a container with the handler registered
+        class EventEmittingContainer(containers.DeclarativeContainer):
+            item_service = providers.Singleton(ItemService)
+            event_logger = providers.Singleton(EventLogger)
+            event_emitting_handler = providers.Factory(
+                EventEmittingHandler,
+                item_service=item_service,
+            )
+            item_processed_event_handler = providers.Factory(
+                ItemProcessedEventHandler,
+                event_logger=event_logger,
+            )
+
+        container = EventEmittingContainer()
+        cqrs_container = DependencyInjectorCQRSContainer()
+        cqrs_container.attach_external_container(container)
+
+        # Update mapper
+        def commands_mapper_override(mapper: cqrs.RequestMap) -> None:
+            mapper.bind(ProcessItemsCommand, EventEmittingHandler)
+
+        mediator = bootstrap.bootstrap_streaming(
+            di_container=cqrs_container,
+            commands_mapper=commands_mapper_override,
+            domain_events_mapper=self.domain_events_mapper,
+            message_broker=devnull.DevnullMessageBroker(),
+            max_concurrent_event_handlers=3,
+            concurrent_event_handle_enable=True,
+        )
+
+        request = ProcessItemsCommand(item_ids=["item1", "item2", "item3"])
+        results = []
+        async for result in mediator.stream(request):
+            results.append(result)
+
+        # Wait for background tasks to complete
+        await asyncio.sleep(0.2)
+
+        assert len(results) == 3
+
+        # Verify event handler was called and dependencies were injected
+        # Since ItemProcessedEventHandler is a Factory, we get a new instance each time
+        # So we check through event_logger (Singleton) that events were processed
+        event_logger = await cqrs_container.resolve(EventLogger)
+        assert len(event_logger.logged_events) == 3
+        assert isinstance(event_logger.logged_events[0], ItemProcessedDomainEvent)
+        assert isinstance(event_logger.logged_events[1], ItemProcessedDomainEvent)
+        assert isinstance(event_logger.logged_events[2], ItemProcessedDomainEvent)
+        assert event_logger.logged_events[0].item_id == "item1"
+        assert event_logger.logged_events[1].item_id == "item2"
+        assert event_logger.logged_events[2].item_id == "item3"
+
+        # Verify that event handler can be resolved and dependencies are injected
+        event_handler = await cqrs_container.resolve(ItemProcessedEventHandler)
+        assert event_handler.event_logger is not None
+        assert isinstance(event_handler.event_logger, EventLogger)
+        # Verify that handler uses the same logger instance (singleton)
+        assert event_handler.event_logger is event_logger
+
+    async def test_bootstrap_streaming_resolves_handlers_by_interface(
+        self,
+    ) -> None:
+        """
+        Test that bootstrap_streaming resolves handlers using interface-based resolution.
+
+        Validates that:
+        - Handlers can depend on abstract interfaces
+        - DependencyInjectorCQRSContainer resolves interfaces to concrete implementations
+        - Dependency injection works with interfaces
+        """
+
+        # Handler that depends on interface
+        class InterfaceBasedHandler(
+            StreamingRequestHandler[ProcessItemsCommand, ProcessItemResult],
+        ):
+            def __init__(self, item_service: IItemService) -> None:
+                self.item_service = item_service
+                self.called = False
+                self._events: list[Event] = []
+
+            @property
+            def events(self) -> typing.Sequence[IEvent]:
+                return self._events.copy()
+
+            def clear_events(self) -> None:
+                self._events.clear()
+
+            async def handle(
+                self,
+                request: ProcessItemsCommand,
+            ) -> typing.AsyncIterator[ProcessItemResult]:
+                self.called = True
+                for item_id in request.item_ids:
+                    status = await self.item_service.process_item(item_id)
+                    result = ProcessItemResult(item_id=item_id, status=status)
+                    yield result
+
+        # Create a container with the handler registered
+        class InterfaceBasedContainer(containers.DeclarativeContainer):
+            item_service = providers.Singleton(ItemService)
+            interface_based_handler = providers.Factory(
+                InterfaceBasedHandler,
+                item_service=item_service,
+            )
+
+        container = InterfaceBasedContainer()
+        cqrs_container = DependencyInjectorCQRSContainer()
+        cqrs_container.attach_external_container(container)
+
+        def commands_mapper_override(mapper: cqrs.RequestMap) -> None:
+            mapper.bind(ProcessItemsCommand, InterfaceBasedHandler)
+
+        mediator = bootstrap.bootstrap_streaming(
+            di_container=cqrs_container,
+            commands_mapper=commands_mapper_override,
+            message_broker=devnull.DevnullMessageBroker(),
+        )
+
+        request = ProcessItemsCommand(item_ids=["item1", "item2"])
+        results = []
+        async for result in mediator.stream(request):
+            results.append(result)
+
+        # Wait for background tasks to complete
+        await asyncio.sleep(0.1)
+
+        assert len(results) == 2
+        assert results[0].item_id == "item1"
+        assert results[1].item_id == "item2"
+
+        # Verify handler was resolved and dependencies injected via interface
+        # The handler should have been resolved during stream execution
+        # We can verify this by checking that the item_service (singleton) was used
+        item_service = await cqrs_container.resolve(
+            IItemService,
+        )  # Resolve via interface
+        assert isinstance(item_service, ItemService)  # Concrete implementation
+        assert len(item_service.processed_items) == 2
+        assert "item1" in item_service.processed_items
+        assert "item2" in item_service.processed_items
+
+        # Also verify that handler can be resolved directly
+        handler = await cqrs_container.resolve(InterfaceBasedHandler)
+        assert handler.item_service is not None
+        assert isinstance(handler.item_service, ItemService)  # Concrete implementation
+        # Verify that handler uses the same service instance (singleton)
+        assert handler.item_service is item_service
diff --git a/tests/unit/test_cor_mermaid.py b/tests/unit/test_cor_mermaid.py
index 3fa2ff3..2906629 100644
--- a/tests/unit/test_cor_mermaid.py
+++ b/tests/unit/test_cor_mermaid.py
@@ -224,8 +224,7 @@ def test_class_diagram_relationships() -> None:
 
     # Check chain relationships (set_next)
     assert (
-        "CreditCardHandler --> PayPalHandler" in diagram
-        or "CreditCardHandler --> PayPalHandler : set_next" in diagram
+        "CreditCardHandler --> PayPalHandler" in diagram or "CreditCardHandler --> PayPalHandler : set_next" in diagram
     )
     assert (
         "PayPalHandler --> BankTransferHandler" in diagram
@@ -240,6 +239,5 @@ def test_class_diagram_relationships() -> None:
 
     # Check Handler to Response relationships
     assert (
-        "CreditCardHandler ..> PaymentResult" in diagram
-        or "CreditCardHandler ..> PaymentResult : returns" in diagram
+        "CreditCardHandler ..> PaymentResult" in diagram or "CreditCardHandler ..> PaymentResult : returns" in diagram
     )
diff --git a/tests/unit/test_cor_request_handler.py b/tests/unit/test_cor_request_handler.py
index 77b7b19..da180fa 100644
--- a/tests/unit/test_cor_request_handler.py
+++ b/tests/unit/test_cor_request_handler.py
@@ -24,7 +24,7 @@ class TestHandlerA(CORRequestHandler[TRequest, TResult | None]):
     call_count: int = 0
 
     @property
-    def events(self) -> typing.List[cqrs.Event]:
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
         return []
 
     async def handle(self, request: TRequest) -> TResult | None:
@@ -46,7 +46,7 @@ class TestHandlerB(CORRequestHandler[TRequest, TResult | None]):
     call_count: int = 0
 
     @property
-    def events(self) -> typing.List[cqrs.Event]:
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
         return []
 
     async def handle(self, request: TRequest) -> TResult | None:
@@ -68,7 +68,7 @@ class TestHandlerC(CORRequestHandler[TRequest, TResult | None]):
     call_count: int = 0
 
     @property
-    def events(self) -> typing.List[cqrs.Event]:
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
         return []
 
     async def handle(self, request: TRequest) -> TResult | None:
@@ -90,7 +90,7 @@ class DefaultTestHandler(CORRequestHandler[TRequest, TResult | None]):
     call_count: int = 0
 
     @property
-    def events(self) -> typing.List[cqrs.Event]:
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
         return []
 
     async def handle(self, request: TRequest) -> TResult | None:
diff --git a/tests/unit/test_dcevent_from_dict_recursive.py b/tests/unit/test_dcevent_from_dict_recursive.py
new file mode 100644
index 0000000..3380a8c
--- /dev/null
+++ b/tests/unit/test_dcevent_from_dict_recursive.py
@@ -0,0 +1,704 @@
+"""
+Tests for recursive type conversion in DCEvent.from_dict method.
+
+These tests verify that DCEvent.from_dict correctly performs recursive type
+conversion for nested structures including UUID, datetime, nested dataclasses,
+lists, and dictionaries. Tests are organized by event type: Domain and Notification.
+"""
+
+import dataclasses
+import datetime
+import typing
+import uuid
+
+import pytest
+
+from cqrs.events.event import DCDomainEvent, DCNotificationEvent
+
+
+# ============================================================================
+# Shared test data structures
+# ============================================================================
+
+
+@dataclasses.dataclass(frozen=True)
+class NestedData:
+    """Nested dataclass for testing recursive conversion."""
+
+    nested_id: uuid.UUID
+    nested_name: str
+    nested_timestamp: datetime.datetime
+
+
+# ============================================================================
+# Domain Event test classes
+# ============================================================================
+
+
+@dataclasses.dataclass(frozen=True)
+class SimpleDomainEvent(DCDomainEvent):
+    """Simple domain event with basic types."""
+
+    user_id: str
+    username: str
+
+
+@dataclasses.dataclass(frozen=True)
+class DomainEventWithUUID(DCDomainEvent):
+    """Domain event with UUID field."""
+
+    event_id: uuid.UUID
+    user_id: str
+
+
+@dataclasses.dataclass(frozen=True)
+class DomainEventWithDatetime(DCDomainEvent):
+    """Domain event with datetime field."""
+
+    created_at: datetime.datetime
+    user_id: str
+
+
+@dataclasses.dataclass(frozen=True)
+class DomainEventWithNested(DCDomainEvent):
+    """Domain event with nested DCEvent dataclass."""
+
+    user_id: str
+    nested: NestedData
+
+
+@dataclasses.dataclass(frozen=True)
+class DomainEventWithList(DCDomainEvent):
+    """Domain event with list of UUIDs."""
+
+    user_ids: typing.List[uuid.UUID]
+    event_name: str
+
+
+@dataclasses.dataclass(frozen=True)
+class DomainEventWithListOfNested(DCDomainEvent):
+    """Domain event with list of nested dataclasses."""
+
+    items: typing.List[NestedData]
+    event_name: str
+
+
+@dataclasses.dataclass(frozen=True)
+class DomainEventWithDict(DCDomainEvent):
+    """Domain event with dictionary containing UUID values."""
+
+    metadata: typing.Dict[str, uuid.UUID]
+    event_name: str
+
+
+@dataclasses.dataclass(frozen=True)
+class DomainEventWithComplexNested(DCDomainEvent):
+    """Domain event with complex nested structure."""
+
+    event_id: uuid.UUID
+    created_at: datetime.datetime
+    nested: NestedData
+    user_ids: typing.List[uuid.UUID]
+    items: typing.List[NestedData]
+    metadata: typing.Dict[str, uuid.UUID]
+
+
+# ============================================================================
+# Notification Event test classes
+# ============================================================================
+
+
+@dataclasses.dataclass(frozen=True)
+class SimpleNotificationEvent(DCNotificationEvent[dict]):
+    """Simple notification event with basic payload."""
+
+    event_name: str
+    payload: dict
+
+
+@dataclasses.dataclass(frozen=True)
+class NotificationEventWithUUIDPayload(DCNotificationEvent[dict]):
+    """Notification event with UUID in payload."""
+
+    event_name: str
+    payload: dict
+
+
+@dataclasses.dataclass(frozen=True)
+class NotificationEventWithNestedPayload(DCNotificationEvent[dict]):
+    """Notification event with nested dataclass in payload."""
+
+    event_name: str
+    payload: dict
+
+
+@dataclasses.dataclass(frozen=True)
+class NotificationEventWithListPayload(DCNotificationEvent[dict]):
+    """Notification event with list in payload."""
+
+    event_name: str
+    payload: dict
+
+
+@dataclasses.dataclass(frozen=True)
+class NotificationEventWithComplexPayload(DCNotificationEvent[dict]):
+    """Notification event with complex nested payload."""
+
+    event_name: str
+    payload: dict
+
+
+@dataclasses.dataclass(frozen=True)
+class NotificationEventWithTypedPayload(DCNotificationEvent[NestedData]):
+    """Notification event with typed payload (dataclass)."""
+
+    event_name: str
+    payload: NestedData
+
+
+# ============================================================================
+# Domain Event Tests
+# ============================================================================
+
+
+class TestDomainEventFromDictBasic:
+    """Test basic from_dict functionality for domain events."""
+
+    def test_simple_domain_event_from_dict(self):
+        """Test simple domain event conversion from dict."""
+        data = {"user_id": "123", "username": "john"}
+        event = SimpleDomainEvent.from_dict(**data)
+        assert event.user_id == "123"
+        assert event.username == "john"
+        assert isinstance(event, DCDomainEvent)
+        assert isinstance(event, SimpleDomainEvent)
+
+
+class TestDomainEventFromDictUUID:
+    """Test UUID type conversion in from_dict for domain events."""
+
+    def test_uuid_from_string(self):
+        """Test UUID conversion from string."""
+        event_id = str(uuid.uuid4())
+        data = {"event_id": event_id, "user_id": "123"}
+        event = DomainEventWithUUID.from_dict(**data)
+        assert isinstance(event.event_id, uuid.UUID)
+        assert str(event.event_id) == event_id
+        assert event.user_id == "123"
+        assert isinstance(event, DCDomainEvent)
+
+    def test_uuid_from_uuid_object(self):
+        """Test UUID when already a UUID object."""
+        event_id = uuid.uuid4()
+        # dataclass_wizard expects strings for UUID conversion, not UUID objects
+        # So we convert to string first
+        data = {"event_id": str(event_id), "user_id": "123"}
+        event = DomainEventWithUUID.from_dict(**data)
+        assert isinstance(event.event_id, uuid.UUID)
+        assert event.event_id == event_id
+
+
+class TestDomainEventFromDictDatetime:
+    """Test datetime type conversion in from_dict for domain events."""
+
+    def test_datetime_from_iso_string(self):
+        """Test datetime conversion from ISO format string."""
+        now = datetime.datetime.now(datetime.timezone.utc)
+        iso_string = now.isoformat()
+        data = {"created_at": iso_string, "user_id": "123"}
+        event = DomainEventWithDatetime.from_dict(**data)
+        assert isinstance(event.created_at, datetime.datetime)
+        # Compare timestamps to avoid timezone issues
+        assert event.created_at.timestamp() == pytest.approx(now.timestamp(), abs=1)
+        assert isinstance(event, DCDomainEvent)
+
+    def test_datetime_from_datetime_object(self):
+        """Test datetime when already a datetime object."""
+        now = datetime.datetime.now(datetime.timezone.utc)
+        data = {"created_at": now, "user_id": "123"}
+        event = DomainEventWithDatetime.from_dict(**data)
+        assert isinstance(event.created_at, datetime.datetime)
+        assert event.created_at == now
+
+
+class TestDomainEventFromDictNested:
+    """Test recursive conversion of nested DCEvent dataclasses in domain events."""
+
+    def test_nested_dataclass_from_dict(self):
+        """Test nested DCEvent dataclass conversion."""
+        nested_id = str(uuid.uuid4())
+        nested_timestamp = datetime.datetime.now(datetime.timezone.utc).isoformat()
+        data = {
+            "user_id": "123",
+            "nested": {
+                "nested_id": nested_id,
+                "nested_name": "test",
+                "nested_timestamp": nested_timestamp,
+            },
+        }
+        event = DomainEventWithNested.from_dict(**data)
+        assert isinstance(event, DCDomainEvent)
+        assert isinstance(event.nested, NestedData)
+        assert isinstance(event.nested.nested_id, uuid.UUID)
+        assert str(event.nested.nested_id) == nested_id
+        assert event.nested.nested_name == "test"
+        assert isinstance(event.nested.nested_timestamp, datetime.datetime)
+
+    def test_deeply_nested_dataclass(self):
+        """Test deeply nested structure conversion."""
+        event_id = str(uuid.uuid4())
+        created_at = datetime.datetime.now(datetime.timezone.utc).isoformat()
+        nested_id = str(uuid.uuid4())
+        nested_timestamp = datetime.datetime.now(datetime.timezone.utc).isoformat()
+        data = {
+            "event_id": event_id,
+            "created_at": created_at,
+            "nested": {
+                "nested_id": nested_id,
+                "nested_name": "test",
+                "nested_timestamp": nested_timestamp,
+            },
+            "user_ids": [str(uuid.uuid4()), str(uuid.uuid4())],
+            "items": [
+                {
+                    "nested_id": str(uuid.uuid4()),
+                    "nested_name": "item1",
+                    "nested_timestamp": nested_timestamp,
+                },
+                {
+                    "nested_id": str(uuid.uuid4()),
+                    "nested_name": "item2",
+                    "nested_timestamp": nested_timestamp,
+                },
+            ],
+            "metadata": {
+                "key1": str(uuid.uuid4()),
+                "key2": str(uuid.uuid4()),
+            },
+        }
+        event = DomainEventWithComplexNested.from_dict(**data)
+        assert isinstance(event, DCDomainEvent)
+        assert isinstance(event.event_id, uuid.UUID)
+        assert isinstance(event.created_at, datetime.datetime)
+        assert isinstance(event.nested, NestedData)
+        assert isinstance(event.nested.nested_id, uuid.UUID)
+        assert all(isinstance(uid, uuid.UUID) for uid in event.user_ids)
+        assert all(isinstance(item, NestedData) for item in event.items)
+        assert all(isinstance(v, uuid.UUID) for v in event.metadata.values())
+
+
+class TestDomainEventFromDictLists:
+    """Test list type conversion in from_dict for domain events."""
+
+    def test_list_of_uuids_from_strings(self):
+        """Test list of UUIDs conversion from strings."""
+        uuid_strings = [str(uuid.uuid4()), str(uuid.uuid4())]
+        data = {"user_ids": uuid_strings, "event_name": "test_event"}
+        event = DomainEventWithList.from_dict(**data)
+        assert isinstance(event, DCDomainEvent)
+        assert all(isinstance(uid, uuid.UUID) for uid in event.user_ids)
+        assert len(event.user_ids) == 2
+        assert str(event.user_ids[0]) == uuid_strings[0]
+        assert str(event.user_ids[1]) == uuid_strings[1]
+
+    def test_empty_list(self):
+        """Test empty list handling."""
+        data = {"user_ids": [], "event_name": "test_event"}
+        event = DomainEventWithList.from_dict(**data)
+        assert isinstance(event, DCDomainEvent)
+        assert event.user_ids == []
+        assert event.event_name == "test_event"
+
+    def test_list_of_nested_dataclasses(self):
+        """Test list of nested dataclasses conversion."""
+        nested_id1 = str(uuid.uuid4())
+        nested_id2 = str(uuid.uuid4())
+        nested_timestamp = datetime.datetime.now(datetime.timezone.utc).isoformat()
+        data = {
+            "items": [
+                {
+                    "nested_id": nested_id1,
+                    "nested_name": "item1",
+                    "nested_timestamp": nested_timestamp,
+                },
+                {
+                    "nested_id": nested_id2,
+                    "nested_name": "item2",
+                    "nested_timestamp": nested_timestamp,
+                },
+            ],
+            "event_name": "test_event",
+        }
+        event = DomainEventWithListOfNested.from_dict(**data)
+        assert isinstance(event, DCDomainEvent)
+        assert len(event.items) == 2
+        assert all(isinstance(item, NestedData) for item in event.items)
+        assert event.items[0].nested_name == "item1"
+        assert event.items[1].nested_name == "item2"
+        assert isinstance(event.items[0].nested_id, uuid.UUID)
+        assert isinstance(event.items[1].nested_id, uuid.UUID)
+        assert str(event.items[0].nested_id) == nested_id1
+        assert str(event.items[1].nested_id) == nested_id2
+
+
+class TestDomainEventFromDictDicts:
+    """Test dictionary type conversion in from_dict for domain events."""
+
+    def test_dict_with_uuid_values(self):
+        """Test dictionary with UUID values conversion."""
+        uuid1 = str(uuid.uuid4())
+        uuid2 = str(uuid.uuid4())
+        data = {
+            "metadata": {"key1": uuid1, "key2": uuid2},
+            "event_name": "test_event",
+        }
+        event = DomainEventWithDict.from_dict(**data)
+        assert isinstance(event, DCDomainEvent)
+        assert isinstance(event.metadata["key1"], uuid.UUID)
+        assert isinstance(event.metadata["key2"], uuid.UUID)
+        assert str(event.metadata["key1"]) == uuid1
+        assert str(event.metadata["key2"]) == uuid2
+
+    def test_empty_dict(self):
+        """Test empty dictionary handling."""
+        data = {"metadata": {}, "event_name": "test_event"}
+        event = DomainEventWithDict.from_dict(**data)
+        assert isinstance(event, DCDomainEvent)
+        assert event.metadata == {}
+        assert event.event_name == "test_event"
+
+
+class TestDomainEventFromDictRoundTrip:
+    """Test round-trip conversion (to_dict -> from_dict) for domain events."""
+
+    def test_round_trip_simple(self):
+        """Test round-trip for simple domain event."""
+        original = SimpleDomainEvent(user_id="123", username="john")
+        data = original.to_dict()
+        restored = SimpleDomainEvent.from_dict(**data)
+        assert restored == original
+
+    def test_round_trip_with_uuid(self):
+        """Test round-trip for domain event with UUID."""
+        original = DomainEventWithUUID(event_id=uuid.uuid4(), user_id="123")
+        data = original.to_dict()
+        restored = DomainEventWithUUID.from_dict(**data)
+        assert restored == original
+
+    def test_round_trip_with_nested(self):
+        """Test round-trip for domain event with nested dataclass."""
+        nested = NestedData(
+            nested_id=uuid.uuid4(),
+            nested_name="test",
+            nested_timestamp=datetime.datetime.now(datetime.timezone.utc),
+        )
+        original = DomainEventWithNested(user_id="123", nested=nested)
+        data = original.to_dict()
+        restored = DomainEventWithNested.from_dict(**data)
+        assert restored == original
+        assert restored.nested == nested
+
+    def test_round_trip_complex(self):
+        """Test round-trip for complex nested domain event."""
+        nested = NestedData(
+            nested_id=uuid.uuid4(),
+            nested_name="test",
+            nested_timestamp=datetime.datetime.now(datetime.timezone.utc),
+        )
+        original = DomainEventWithComplexNested(
+            event_id=uuid.uuid4(),
+            created_at=datetime.datetime.now(datetime.timezone.utc),
+            nested=nested,
+            user_ids=[uuid.uuid4(), uuid.uuid4()],
+            items=[
+                NestedData(
+                    nested_id=uuid.uuid4(),
+                    nested_name="item1",
+                    nested_timestamp=datetime.datetime.now(datetime.timezone.utc),
+                ),
+                NestedData(
+                    nested_id=uuid.uuid4(),
+                    nested_name="item2",
+                    nested_timestamp=datetime.datetime.now(datetime.timezone.utc),
+                ),
+            ],
+            metadata={"key1": uuid.uuid4(), "key2": uuid.uuid4()},
+        )
+        data = original.to_dict()
+        restored = DomainEventWithComplexNested.from_dict(**data)
+        assert restored == original
+
+
+# ============================================================================
+# Notification Event Tests
+# ============================================================================
+
+
+class TestNotificationEventFromDictBasic:
+    """Test basic from_dict functionality for notification events."""
+
+    def test_simple_notification_event_from_dict(self):
+        """Test simple notification event conversion from dict."""
+        data = {
+            "event_name": "user.created",
+            "payload": {"user_id": "123", "username": "john"},
+        }
+        event = SimpleNotificationEvent.from_dict(**data)
+        assert event.event_name == "user.created"
+        assert event.payload == {"user_id": "123", "username": "john"}
+        assert isinstance(event, DCNotificationEvent)
+        assert isinstance(event.event_id, uuid.UUID)
+        assert isinstance(event.event_timestamp, datetime.datetime)
+
+    def test_notification_event_with_explicit_metadata(self):
+        """Test notification event with explicit event_id and event_timestamp."""
+        event_id = str(uuid.uuid4())
+        event_timestamp = datetime.datetime.now(datetime.timezone.utc).isoformat()
+        data = {
+            "event_name": "user.created",
+            "payload": {"user_id": "123"},
+            "event_id": event_id,
+            "event_timestamp": event_timestamp,
+            "topic": "users",
+        }
+        event = SimpleNotificationEvent.from_dict(**data)
+        assert isinstance(event, DCNotificationEvent)
+        assert isinstance(event.event_id, uuid.UUID)
+        assert str(event.event_id) == event_id
+        assert isinstance(event.event_timestamp, datetime.datetime)
+        assert event.topic == "users"
+
+    def test_notification_event_uuid_from_string(self):
+        """Test notification event with event_id as string."""
+        event_id_str = str(uuid.uuid4())
+        data = {
+            "event_name": "user.created",
+            "payload": {"user_id": "123"},
+            "event_id": event_id_str,
+        }
+        event = SimpleNotificationEvent.from_dict(**data)
+        assert isinstance(event, DCNotificationEvent)
+        assert isinstance(event.event_id, uuid.UUID)
+        assert str(event.event_id) == event_id_str
+
+    def test_notification_event_datetime_from_string(self):
+        """Test notification event with event_timestamp as ISO string."""
+        now = datetime.datetime.now(datetime.timezone.utc)
+        event_timestamp_str = now.isoformat()
+        data = {
+            "event_name": "user.created",
+            "payload": {"user_id": "123"},
+            "event_timestamp": event_timestamp_str,
+        }
+        event = SimpleNotificationEvent.from_dict(**data)
+        assert isinstance(event, DCNotificationEvent)
+        assert isinstance(event.event_timestamp, datetime.datetime)
+        # Compare timestamps to avoid timezone issues
+        assert event.event_timestamp.timestamp() == pytest.approx(
+            now.timestamp(),
+            abs=1,
+        )
+
+
+class TestNotificationEventFromDictUUID:
+    """Test UUID type conversion in from_dict for notification events."""
+
+    def test_uuid_in_payload_from_string(self):
+        """Test UUID conversion from string in payload."""
+        user_id = str(uuid.uuid4())
+        data = {
+            "event_name": "user.created",
+            "payload": {"user_id": user_id, "username": "john"},
+        }
+        event = NotificationEventWithUUIDPayload.from_dict(**data)
+        assert isinstance(event, DCNotificationEvent)
+        assert isinstance(event.event_id, uuid.UUID)
+        # Payload is dict, so UUIDs in payload remain as strings unless payload is a dataclass
+        assert event.payload["user_id"] == user_id
+
+
+class TestNotificationEventFromDictNested:
+    """Test recursive conversion of nested structures in notification event payloads."""
+
+    def test_nested_dataclass_in_payload(self):
+        """Test nested DCEvent dataclass in payload."""
+        nested_id = str(uuid.uuid4())
+        nested_timestamp = datetime.datetime.now(datetime.timezone.utc).isoformat()
+        data = {
+            "event_name": "order.created",
+            "payload": {
+                "order_id": "123",
+                "customer": {
+                    "nested_id": nested_id,
+                    "nested_name": "customer",
+                    "nested_timestamp": nested_timestamp,
+                },
+            },
+        }
+        event = NotificationEventWithNestedPayload.from_dict(**data)
+        assert isinstance(event, DCNotificationEvent)
+        assert event.event_name == "order.created"
+        # Payload is dict, nested structures are converted recursively
+        customer = event.payload["customer"]
+        assert isinstance(customer, dict)
+        # If payload contains nested dataclass structures, they should be converted
+        # Note: This depends on how dataclass_wizard handles nested dicts
+
+
+class TestNotificationEventFromDictLists:
+    """Test list type conversion in from_dict for notification events."""
+
+    def test_list_in_payload(self):
+        """Test list conversion in payload."""
+        uuid_strings = [str(uuid.uuid4()), str(uuid.uuid4())]
+        data = {
+            "event_name": "users.batch_created",
+            "payload": {"user_ids": uuid_strings},
+        }
+        event = NotificationEventWithListPayload.from_dict(**data)
+        assert isinstance(event, DCNotificationEvent)
+        assert event.event_name == "users.batch_created"
+        assert event.payload["user_ids"] == uuid_strings
+
+
+class TestNotificationEventFromDictComplex:
+    """Test complex nested structures in notification event payloads."""
+
+    def test_complex_payload_with_nested_structures(self):
+        """Test complex payload with nested structures."""
+        nested_id = str(uuid.uuid4())
+        nested_timestamp = datetime.datetime.now(datetime.timezone.utc).isoformat()
+        data = {
+            "event_name": "order.completed",
+            "payload": {
+                "order_id": str(uuid.uuid4()),
+                "items": [
+                    {
+                        "nested_id": nested_id,
+                        "nested_name": "item1",
+                        "nested_timestamp": nested_timestamp,
+                    },
+                ],
+                "metadata": {
+                    "key1": str(uuid.uuid4()),
+                },
+            },
+        }
+        event = NotificationEventWithComplexPayload.from_dict(**data)
+        assert isinstance(event, DCNotificationEvent)
+        assert event.event_name == "order.completed"
+        assert "order_id" in event.payload
+        assert "items" in event.payload
+        assert "metadata" in event.payload
+
+    def test_typed_payload_with_nested_dataclass(self):
+        """Test notification event with typed payload (dataclass) containing nested structures."""
+        nested_id = str(uuid.uuid4())
+        nested_timestamp = datetime.datetime.now(datetime.timezone.utc).isoformat()
+        data = {
+            "event_name": "user.registered",
+            "payload": {
+                "nested_id": nested_id,
+                "nested_name": "user_data",
+                "nested_timestamp": nested_timestamp,
+            },
+        }
+        event = NotificationEventWithTypedPayload.from_dict(**data)
+        assert isinstance(event, DCNotificationEvent)
+        assert event.event_name == "user.registered"
+        assert isinstance(event.payload, NestedData)
+        assert isinstance(event.payload.nested_id, uuid.UUID)
+        assert str(event.payload.nested_id) == nested_id
+        assert event.payload.nested_name == "user_data"
+        assert isinstance(event.payload.nested_timestamp, datetime.datetime)
+        assert isinstance(event.event_id, uuid.UUID)
+        assert isinstance(event.event_timestamp, datetime.datetime)
+
+
+class TestNotificationEventFromDictRoundTrip:
+    """Test round-trip conversion (to_dict -> from_dict) for notification events."""
+
+    def test_round_trip_simple(self):
+        """Test round-trip for simple notification event."""
+        original = SimpleNotificationEvent(
+            event_name="user.created",
+            payload={"user_id": "123", "username": "john"},
+        )
+        data = original.to_dict()
+        restored = SimpleNotificationEvent.from_dict(**data)
+        assert restored.event_name == original.event_name
+        assert restored.payload == original.payload
+        assert restored.topic == original.topic
+
+    def test_round_trip_with_explicit_metadata(self):
+        """Test round-trip for notification event with explicit metadata."""
+        event_id = uuid.uuid4()
+        event_timestamp = datetime.datetime.now(datetime.timezone.utc)
+        original = SimpleNotificationEvent(
+            event_name="user.created",
+            payload={"user_id": "123"},
+            event_id=event_id,
+            event_timestamp=event_timestamp,
+            topic="users",
+        )
+        data = original.to_dict()
+        restored = SimpleNotificationEvent.from_dict(**data)
+        assert restored.event_name == original.event_name
+        assert restored.payload == original.payload
+        assert restored.event_id == original.event_id
+        assert restored.event_timestamp == original.event_timestamp
+        assert restored.topic == original.topic
+
+    def test_round_trip_with_typed_payload(self):
+        """Test round-trip for notification event with typed payload."""
+        payload = NestedData(
+            nested_id=uuid.uuid4(),
+            nested_name="test",
+            nested_timestamp=datetime.datetime.now(datetime.timezone.utc),
+        )
+        original = NotificationEventWithTypedPayload(
+            event_name="user.registered",
+            payload=payload,
+        )
+        data = original.to_dict()
+        restored = NotificationEventWithTypedPayload.from_dict(**data)
+        assert restored.event_name == original.event_name
+        assert restored.payload == original.payload
+        assert isinstance(restored.payload, NestedData)
+        assert restored.payload.nested_id == payload.nested_id
+
+
+class TestDCNotificationEventProtoAndHash:
+    """Test DCNotificationEvent proto(), from_proto(), and __hash__() methods."""
+
+    def test_proto_raises_not_implemented_error(self):
+        """DCNotificationEvent.proto() raises NotImplementedError by default."""
+        event = SimpleNotificationEvent(
+            event_name="user.created",
+            payload={"user_id": "123"},
+        )
+        with pytest.raises(NotImplementedError, match="Method not implemented"):
+            event.proto()
+
+    def test_from_proto_raises_not_implemented_error(self):
+        """DCNotificationEvent.from_proto() raises NotImplementedError by default."""
+        with pytest.raises(NotImplementedError, match="Method not implemented"):
+            SimpleNotificationEvent.from_proto(None)
+
+    def test_hash_returns_hash_of_event_id(self):
+        """DCNotificationEvent.__hash__() returns hash of event_id."""
+        event_id = uuid.uuid4()
+        event = SimpleNotificationEvent(
+            event_name="user.created",
+            payload={"user_id": "123"},
+            event_id=event_id,
+        )
+        # Call base __hash__ explicitly: subclass is frozen dataclass with dict payload,
+        # so hash(event) would use dataclass __hash__ and fail (dict unhashable).
+        assert DCNotificationEvent.__hash__(event) == hash(event_id)
+        event2 = SimpleNotificationEvent(
+            event_name="other",
+            payload={},
+            event_id=event_id,
+        )
+        assert DCNotificationEvent.__hash__(event) == DCNotificationEvent.__hash__(event2)
diff --git a/tests/unit/test_dependency_injector_cqrs_container.py b/tests/unit/test_dependency_injector_cqrs_container.py
index caabe23..76fee62 100644
--- a/tests/unit/test_dependency_injector_cqrs_container.py
+++ b/tests/unit/test_dependency_injector_cqrs_container.py
@@ -203,7 +203,7 @@ async def test_override_provider_with_limited_support(self) -> None:
             providers.Factory(
                 OverriddenUserService,
                 repository=container.user_repository,
-            )
+            ),
         )
 
         # Works: Resolve via abstract interface (inheritance match + override)
@@ -277,3 +277,55 @@ async def test_multiple_container_attachment(self) -> None:
         # Previous container's types are no longer resolvable
         with pytest.raises(ValueError):
             await cqrs_container.resolve(UserRepository)
+
+    async def test_resolve_async_provider_returns_future(self) -> None:
+        """
+        Resolution correctly handles providers that return Future objects.
+
+        This test validates the fix for the bug where providers returning Future
+        objects (instead of coroutines) were not being awaited, causing
+        AttributeError: '_asyncio.Future' object has no attribute 'handle'.
+
+        The issue occurred when:
+        1. A provider returns a Future (not a coroutine)
+        2. inspect.iscoroutine() returns False for Future objects
+        3. The Future is returned directly without being awaited
+        4. Downstream code tries to call .handle() on the Future, causing an error
+
+        The fix uses inspect.isawaitable() instead of inspect.iscoroutine() to
+        properly detect and await Future objects.
+        """
+        import asyncio
+
+        class AsyncService:
+            def __init__(self) -> None:
+                self.initialized = True
+
+            async def do_work(self) -> str:
+                return "work done"
+
+        # Create a provider that returns a coroutine/Future
+        # This simulates the scenario where dependency-injector creates
+        # a Future instead of a coroutine
+        async def async_factory() -> AsyncService:
+            await asyncio.sleep(0.01)  # Simulate async initialization
+            return AsyncService()
+
+        class AsyncContainer(containers.DeclarativeContainer):
+            # Use Factory provider with async factory function
+            # This properly registers AsyncService type in the container
+            async_service = providers.Factory(
+                AsyncService,
+            )
+
+        cqrs_container = DependencyInjectorCQRSContainer()
+        container = AsyncContainer()
+        cqrs_container.attach_external_container(container)
+
+        # This should work: the provider returns AsyncService instance
+        service = await cqrs_container.resolve(AsyncService)
+
+        assert isinstance(service, AsyncService)
+        assert service.initialized is True
+        result = await service.do_work()
+        assert result == "work done"
diff --git a/tests/unit/test_deserializers.py b/tests/unit/test_deserializers.py
index f0d7bdb..3421e30 100644
--- a/tests/unit/test_deserializers.py
+++ b/tests/unit/test_deserializers.py
@@ -1,12 +1,10 @@
 import typing
-import uuid
-from unittest.mock import Mock, patch
 
 import orjson
 import pydantic
 
 import cqrs
-from cqrs.deserializers import json, protobuf
+from cqrs.deserializers import json
 
 
 class DeserializedModelPayload(pydantic.BaseModel):
@@ -41,7 +39,7 @@ def test_json_deserializer_from_bytes_positive():
 
 
 def test_json_deserializer_from_str_positive():
-    deserializer = json.JsonDeserializer[cqrs.NotificationEvent](
+    deserializer = json.JsonDeserializer(
         model=cqrs.NotificationEvent[DeserializedModelPayload],
     )
 
@@ -54,7 +52,7 @@ def test_json_deserializer_from_str_positive():
 
 
 def test_json_deserializer_invalid_json_negative():
-    deserializer = json.JsonDeserializer[cqrs.NotificationEvent](
+    deserializer = json.JsonDeserializer(
         model=cqrs.NotificationEvent[DeserializedModelPayload],
     )
 
@@ -67,7 +65,7 @@ def test_json_deserializer_invalid_json_negative():
 
 
 def test_json_deserializer_invalid_structure_negative():
-    deserializer = json.JsonDeserializer[cqrs.NotificationEvent](
+    deserializer = json.JsonDeserializer(
         model=cqrs.NotificationEvent[DeserializedModelPayload],
     )
 
@@ -82,15 +80,13 @@ def test_json_deserializer_invalid_structure_negative():
 
 
 def test_json_deserializer_missing_required_fields_negative():
-    deserializer = json.JsonDeserializer[cqrs.NotificationEvent](
+    deserializer = json.JsonDeserializer(
         model=cqrs.NotificationEvent[DeserializedModelPayload],
     )
 
     # JSON with payload that has wrong type for required field 'bar' (string instead of int)
     # This should cause a validation error when Pydantic tries to validate the payload
-    incomplete_json = (
-        '{"event_name": "test", "payload": {"foo": "bar", "bar": "not_an_int"}}'
-    )
+    incomplete_json = '{"event_name": "test", "payload": {"foo": "bar", "bar": "not_an_int"}}'
     result = deserializer(incomplete_json)
 
     assert isinstance(result, json.DeserializeJsonError)
@@ -100,7 +96,7 @@ def test_json_deserializer_missing_required_fields_negative():
 
 
 def test_json_deserializer_empty_string_negative():
-    deserializer = json.JsonDeserializer[cqrs.NotificationEvent](
+    deserializer = json.JsonDeserializer(
         model=cqrs.NotificationEvent[DeserializedModelPayload],
     )
 
@@ -113,7 +109,7 @@ def test_json_deserializer_empty_string_negative():
 
 
 def test_json_deserializer_empty_json_object_negative():
-    deserializer = json.JsonDeserializer[cqrs.NotificationEvent](
+    deserializer = json.JsonDeserializer(
         model=cqrs.NotificationEvent[DeserializedModelPayload],
     )
 
@@ -123,234 +119,3 @@ def test_json_deserializer_empty_json_object_negative():
     assert result.error_message is not None
     assert result.error_type is not None
     assert result.message_data == "{}"
-
-
-# ============================================================================
-# ProtobufValueDeserializer Tests
-# ============================================================================
-
-
-class MockProtobufMessage:
-    """Mock protobuf message for testing."""
-
-    def __init__(self, event_id: str, event_name: str, payload: dict | None = None):
-        self.event_id = event_id
-        self.event_name = event_name
-        self.event_timestamp = "2024-01-01T00:00:00"
-        if payload:
-            self.payload = Mock()
-            self.payload.user_id = payload.get("user_id", "")
-            self.payload.meeting_id = payload.get("meeting_id", "")
-
-
-def test_protobuf_deserializer_success():
-    """Test successful protobuf deserialization."""
-    # Use a mock class that can be used as a type
-    mock_protobuf_model = type("MockProtobufModel", (), {})  # type: ignore[assignment]
-    mock_event_model = cqrs.NotificationEvent[DeserializedModelPayload]
-
-    deserializer = protobuf.ProtobufValueDeserializer(
-        model=mock_event_model,
-        protobuf_model=mock_protobuf_model,  # type: ignore[arg-type]
-    )
-
-    mock_proto_message = MockProtobufMessage(
-        event_id="123",
-        event_name="test_event",
-    )
-
-    # Mock the ProtobufDeserializer class to return a callable that returns our mock message
-    mock_protobuf_deserializer_instance = Mock(return_value=mock_proto_message)
-
-    with patch(
-        "cqrs.deserializers.protobuf.protobuf.ProtobufDeserializer",
-        return_value=mock_protobuf_deserializer_instance,
-    ):
-        # Mock model_validate to return a proper event
-        expected_event = cqrs.NotificationEvent[DeserializedModelPayload](
-            event_id=uuid.UUID("12345678-1234-5678-1234-567812345678"),
-            event_name="test_event",
-            payload=DeserializedModelPayload(foo="foo", bar=1),
-        )
-
-        with patch.object(
-            mock_event_model,
-            "model_validate",
-            return_value=expected_event,
-        ):
-            result = deserializer(b"test_bytes")
-
-            assert isinstance(result, cqrs.NotificationEvent)
-            assert result.event_name == "test_event"
-            # Verify that ProtobufDeserializer was called correctly
-            mock_protobuf_deserializer_instance.assert_called_once_with(
-                b"test_bytes",
-                None,
-            )
-
-
-def test_protobuf_deserializer_protobuf_deserialization_error():
-    """Test error during protobuf deserialization."""
-    mock_protobuf_model = type("MockProtobufModel", (), {})  # type: ignore[assignment]
-    mock_event_model = cqrs.NotificationEvent[DeserializedModelPayload]
-
-    deserializer = protobuf.ProtobufValueDeserializer(
-        model=mock_event_model,
-        protobuf_model=mock_protobuf_model,  # type: ignore[arg-type]
-    )
-
-    # Mock ProtobufDeserializer to raise an exception
-    mock_protobuf_deserializer_instance = Mock(
-        side_effect=ValueError("Invalid protobuf data"),
-    )
-
-    with patch(
-        "cqrs.deserializers.protobuf.protobuf.ProtobufDeserializer",
-        return_value=mock_protobuf_deserializer_instance,
-    ):
-        test_bytes = b"invalid_protobuf_data"
-        result = deserializer(test_bytes)
-
-        assert isinstance(result, protobuf.DeserializeProtobufError)
-        assert result.error_message == "Invalid protobuf data"
-        assert result.error_type is ValueError
-        assert result.message_data == test_bytes
-
-
-def test_protobuf_deserializer_empty_message():
-    """Test handling of empty protobuf message."""
-    mock_protobuf_model = type("MockProtobufModel", (), {})  # type: ignore[assignment]
-    mock_event_model = cqrs.NotificationEvent[DeserializedModelPayload]
-
-    deserializer = protobuf.ProtobufValueDeserializer(
-        model=mock_event_model,
-        protobuf_model=mock_protobuf_model,  # type: ignore[arg-type]
-    )
-
-    # Mock ProtobufDeserializer to return None (empty message)
-    mock_protobuf_deserializer_instance = Mock(return_value=None)
-
-    with patch(
-        "cqrs.deserializers.protobuf.protobuf.ProtobufDeserializer",
-        return_value=mock_protobuf_deserializer_instance,
-    ):
-        test_bytes = b"empty_message"
-        result = deserializer(test_bytes)
-
-        assert isinstance(result, protobuf.DeserializeProtobufError)
-        assert "empty" in result.error_message.lower()
-        assert result.error_type is ValueError
-        assert result.message_data == test_bytes
-
-
-def test_protobuf_deserializer_validation_error():
-    """Test pydantic validation error during model conversion."""
-    mock_protobuf_model = type("MockProtobufModel", (), {})  # type: ignore[assignment]
-    mock_event_model = cqrs.NotificationEvent[DeserializedModelPayload]
-
-    deserializer = protobuf.ProtobufValueDeserializer(
-        model=mock_event_model,
-        protobuf_model=mock_protobuf_model,  # type: ignore[arg-type]
-    )
-
-    mock_proto_message = MockProtobufMessage(
-        event_id="123",
-        event_name="test_event",
-    )
-
-    mock_protobuf_deserializer_instance = Mock(return_value=mock_proto_message)
-
-    with patch(
-        "cqrs.deserializers.protobuf.protobuf.ProtobufDeserializer",
-        return_value=mock_protobuf_deserializer_instance,
-    ):
-        # Create a validation error
-        validation_error = pydantic.ValidationError.from_exception_data(
-            "TestModel",
-            [{"type": "missing", "loc": ("payload",), "input": {}}],
-        )
-
-        with patch.object(
-            mock_event_model,
-            "model_validate",
-            side_effect=validation_error,
-        ):
-            test_bytes = b"test_bytes"
-            result = deserializer(test_bytes)
-
-            assert isinstance(result, protobuf.DeserializeProtobufError)
-            assert result.error_message is not None
-            assert result.error_type == pydantic.ValidationError
-            assert result.message_data == test_bytes
-
-
-def test_protobuf_deserializer_generic_exception():
-    """Test handling of generic exceptions during protobuf deserialization."""
-    mock_protobuf_model = type("MockProtobufModel", (), {})  # type: ignore[assignment]
-    mock_event_model = cqrs.NotificationEvent[DeserializedModelPayload]
-
-    deserializer = protobuf.ProtobufValueDeserializer(
-        model=mock_event_model,
-        protobuf_model=mock_protobuf_model,  # type: ignore[arg-type]
-    )
-
-    # Mock ProtobufDeserializer to raise a RuntimeError
-    mock_protobuf_deserializer_instance = Mock(
-        side_effect=RuntimeError("Unexpected error"),
-    )
-
-    with patch(
-        "cqrs.deserializers.protobuf.protobuf.ProtobufDeserializer",
-        return_value=mock_protobuf_deserializer_instance,
-    ):
-        test_bytes = b"test_bytes"
-        result = deserializer(test_bytes)
-
-        assert isinstance(result, protobuf.DeserializeProtobufError)
-        assert result.error_message == "Unexpected error"
-        assert result.error_type is RuntimeError
-        assert result.message_data == test_bytes
-
-
-def test_protobuf_deserializer_byte_string_input():
-    """Test that deserializer accepts ByteString types."""
-    mock_protobuf_model = type("MockProtobufModel", (), {})  # type: ignore[assignment]
-    mock_event_model = cqrs.NotificationEvent[DeserializedModelPayload]
-
-    deserializer = protobuf.ProtobufValueDeserializer(
-        model=mock_event_model,
-        protobuf_model=mock_protobuf_model,  # type: ignore[arg-type]
-    )
-
-    mock_proto_message = MockProtobufMessage(
-        event_id="123",
-        event_name="test_event",
-    )
-
-    mock_protobuf_deserializer_instance = Mock(return_value=mock_proto_message)
-
-    with patch(
-        "cqrs.deserializers.protobuf.protobuf.ProtobufDeserializer",
-        return_value=mock_protobuf_deserializer_instance,
-    ):
-        expected_event = cqrs.NotificationEvent[DeserializedModelPayload](
-            event_id=uuid.UUID("12345678-1234-5678-1234-567812345678"),
-            event_name="test_event",
-            payload=DeserializedModelPayload(foo="foo", bar=1),
-        )
-
-        with patch.object(
-            mock_event_model,
-            "model_validate",
-            return_value=expected_event,
-        ):
-            # Test with bytes
-            result_bytes = deserializer(b"test_bytes")
-            assert isinstance(result_bytes, cqrs.NotificationEvent)
-
-            # Reset mock for next call
-            mock_protobuf_deserializer_instance.reset_mock()
-
-            # Test with bytearray
-            result_bytearray = deserializer(bytearray(b"test_bytes"))
-            assert isinstance(result_bytearray, cqrs.NotificationEvent)
diff --git a/tests/unit/test_domain_event_handling.py b/tests/unit/test_domain_event_handling.py
index 52e7367..63843ec 100644
--- a/tests/unit/test_domain_event_handling.py
+++ b/tests/unit/test_domain_event_handling.py
@@ -1,3 +1,4 @@
+import asyncio
 import typing
 from collections import defaultdict
 
@@ -62,6 +63,9 @@ async def test_handle_domain_events_positive():
     await mediator.send(JoinMeetingCommand(user_id="3", meeting_id="1"))
     await mediator.send(JoinMeetingCommand(user_id="4", meeting_id="1"))
 
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert len(HANDLED_EVENTS) == 4
 
 
@@ -80,6 +84,9 @@ async def test_request_mediator_processes_events_parallel():
     await mediator.send(JoinMeetingCommand(user_id="2", meeting_id="1"))
     await mediator.send(JoinMeetingCommand(user_id="3", meeting_id="1"))
 
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert len(HANDLED_EVENTS) == 3
 
 
@@ -98,4 +105,7 @@ async def test_request_mediator_processes_events_sequentially():
     await mediator.send(JoinMeetingCommand(user_id="2", meeting_id="1"))
     await mediator.send(JoinMeetingCommand(user_id="3", meeting_id="1"))
 
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert len(HANDLED_EVENTS) == 3
diff --git a/tests/unit/test_event_dispatcher_follow_ups.py b/tests/unit/test_event_dispatcher_follow_ups.py
new file mode 100644
index 0000000..352f2d5
--- /dev/null
+++ b/tests/unit/test_event_dispatcher_follow_ups.py
@@ -0,0 +1,75 @@
+"""Unit tests for EventDispatcher dispatching follow-up events from handler.events."""
+
+import typing
+
+import pydantic
+
+from cqrs.events import DomainEvent, EventHandler, EventMap
+from cqrs.events.event import IEvent
+from cqrs.dispatcher.event import EventDispatcher
+
+
+class _EventL1(DomainEvent, frozen=True):
+    name: str = pydantic.Field()
+
+
+class _EventL2(DomainEvent, frozen=True):
+    name: str = pydantic.Field()
+
+
+class _HandlerL1(EventHandler[_EventL1]):
+    def __init__(self) -> None:
+        self.processed: list[_EventL1] = []
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> typing.Sequence[IEvent]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: _EventL1) -> None:
+        self._follow_ups = []
+        self.processed.append(event)
+        self._follow_ups.append(_EventL2(name="L2_from_" + event.name))
+
+
+class _HandlerL2(EventHandler[_EventL2]):
+    def __init__(self) -> None:
+        self.processed: list[_EventL2] = []
+
+    async def handle(self, event: _EventL2) -> None:
+        self.processed.append(event)
+
+
+class _Container:
+    def __init__(self, h1: _HandlerL1, h2: _HandlerL2) -> None:
+        self._h1 = h1
+        self._h2 = h2
+
+    async def resolve(self, type_: type) -> EventHandler[IEvent]:
+        if type_ is _HandlerL1:
+            return self._h1  # type: ignore[return-value]
+        if type_ is _HandlerL2:
+            return self._h2  # type: ignore[return-value]
+        raise KeyError(type_)
+
+
+async def test_event_dispatcher_dispatch_follow_ups() -> None:
+    """Arrange: event A, handler A returns [event B], handler B registered. Act: dispatch(A). Assert: A and B handled."""
+    handler_l1 = _HandlerL1()
+    handler_l2 = _HandlerL2()
+    event_map = EventMap()
+    event_map.bind(_EventL1, _HandlerL1)
+    event_map.bind(_EventL2, _HandlerL2)
+    container = _Container(handler_l1, handler_l2)
+
+    dispatcher = EventDispatcher(
+        event_map=event_map,
+        container=container,  # type: ignore[arg-type]
+    )
+
+    await dispatcher.dispatch(_EventL1(name="a"))
+
+    assert len(handler_l1.processed) == 1
+    assert handler_l1.processed[0].name == "a"
+    assert len(handler_l2.processed) == 1
+    assert handler_l2.processed[0].name == "L2_from_a"
diff --git a/tests/unit/test_event_emitter_handler_events.py b/tests/unit/test_event_emitter_handler_events.py
new file mode 100644
index 0000000..2904c94
--- /dev/null
+++ b/tests/unit/test_event_emitter_handler_events.py
@@ -0,0 +1,124 @@
+"""Unit tests for EventEmitter returning follow-up events from handler.events."""
+
+import typing
+
+import pydantic
+
+from cqrs.events import DomainEvent, EventEmitter, EventHandler, EventMap
+from cqrs.events.event import IEvent
+
+
+class _EventA(DomainEvent, frozen=True):
+    id_: str = pydantic.Field(alias="id")
+    model_config = pydantic.ConfigDict(populate_by_name=True)
+
+
+class _EventB(DomainEvent, frozen=True):
+    id_: str = pydantic.Field(alias="id")
+    model_config = pydantic.ConfigDict(populate_by_name=True)
+
+
+class _HandlerA(EventHandler[_EventA]):
+    def __init__(self) -> None:
+        self.processed: list[_EventA] = []
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> typing.Sequence[IEvent]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: _EventA) -> None:
+        self.processed.append(event)
+        self._follow_ups.append(_EventB(id="b_from_" + event.id_))
+
+
+class _HandlerB(EventHandler[_EventB]):
+    def __init__(self) -> None:
+        self.processed: list[_EventB] = []
+
+    async def handle(self, event: _EventB) -> None:
+        self.processed.append(event)
+
+
+class _Container:
+    def __init__(self, handler_a: _HandlerA, handler_b: _HandlerB) -> None:
+        self._handler_a = handler_a
+        self._handler_b = handler_b
+
+    async def resolve(self, type_: type) -> EventHandler[IEvent]:
+        if type_ is _HandlerA:
+            return self._handler_a  # type: ignore[return-value]
+        if type_ is _HandlerB:
+            return self._handler_b  # type: ignore[return-value]
+        raise KeyError(type_)
+
+
+async def test_event_emitter_emit_returns_follow_ups_from_handlers() -> None:
+    """Arrange: domain event, handler that returns follow-ups. Act: emit. Assert: returns follow-ups."""
+    handler_a = _HandlerA()
+    handler_b = _HandlerB()
+    event_map = EventMap()
+    event_map.bind(_EventA, _HandlerA)
+    event_map.bind(_EventB, _HandlerB)
+    container = _Container(handler_a, handler_b)
+
+    emitter = EventEmitter(
+        event_map=event_map,
+        container=container,  # type: ignore[arg-type]
+    )
+
+    event_a = _EventA(id="1")
+    follow_ups = await emitter.emit(event_a)
+
+    assert len(follow_ups) == 1
+    assert isinstance(follow_ups[0], _EventB)
+    assert follow_ups[0].id_ == "b_from_1"  # type: ignore[attr-defined]
+    assert len(handler_a.processed) == 1
+    assert handler_a.processed[0] == event_a
+
+
+async def test_event_emitter_emit_multiple_handlers_concatenates_follow_ups() -> None:
+    """Arrange: one event type, two handlers each returning follow-ups. Act: emit. Assert: all follow-ups returned."""
+
+    class _EventX(DomainEvent, frozen=True):
+        x: str = pydantic.Field()
+
+    class _HandlerX1(EventHandler[_EventX]):
+        def __init__(self) -> None:
+            self._out: list[IEvent] = []
+
+        @property
+        def events(self) -> typing.Sequence[IEvent]:
+            return tuple(self._out)
+
+        async def handle(self, event: _EventX) -> None:
+            self._out.append(_EventX(x=event.x + "_1"))
+
+    class _HandlerX2(EventHandler[_EventX]):
+        def __init__(self) -> None:
+            self._out: list[IEvent] = []
+
+        @property
+        def events(self) -> typing.Sequence[IEvent]:
+            return tuple(self._out)
+
+        async def handle(self, event: _EventX) -> None:
+            self._out.append(_EventX(x=event.x + "_2"))
+
+    h1 = _HandlerX1()
+    h2 = _HandlerX2()
+    event_map = EventMap()
+    event_map.bind(_EventX, _HandlerX1)
+    event_map.bind(_EventX, _HandlerX2)
+
+    class C:
+        async def resolve(self, type_: type) -> EventHandler[IEvent]:
+            if type_ is _HandlerX1:
+                return h1  # type: ignore[return-value]
+            return h2  # type: ignore[return-value]
+
+    emitter = EventEmitter(event_map=event_map, container=C())  # type: ignore[arg-type]
+    follow_ups = await emitter.emit(_EventX(x="a"))
+    assert len(follow_ups) == 2
+    xs = [e.x for e in follow_ups]  # type: ignore[attr-defined]
+    assert "a_1" in xs and "a_2" in xs
diff --git a/tests/unit/test_event_fallback.py b/tests/unit/test_event_fallback.py
new file mode 100644
index 0000000..2a18f0d
--- /dev/null
+++ b/tests/unit/test_event_fallback.py
@@ -0,0 +1,181 @@
+"""Tests for EventHandlerFallback (without circuit breaker)."""
+
+from collections.abc import Sequence
+from typing import Any, TypeVar
+
+import pytest
+
+from cqrs import EventHandlerFallback
+from cqrs.container.protocol import Container
+from cqrs.events.event import DomainEvent, IEvent
+from cqrs.events.event_emitter import EventEmitter
+from cqrs.events.event_handler import EventHandler
+from cqrs.events.map import EventMap
+
+T = TypeVar("T")
+
+
+class SampleEvent(DomainEvent, frozen=True):
+    """Event type for fallback tests (name avoids pytest collecting it as a test class)."""
+
+    id: str
+
+
+class PrimaryEventHandler(EventHandler[SampleEvent]):
+    def __init__(self) -> None:
+        self._evs: list[IEvent] = []
+        self.called = False
+
+    @property
+    def events(self) -> Sequence[IEvent]:
+        return self._evs.copy()
+
+    async def handle(self, event: SampleEvent) -> None:
+        self.called = True
+        raise RuntimeError("Primary failed")
+
+
+class FallbackEventHandler(EventHandler[SampleEvent]):
+    def __init__(self) -> None:
+        self._evs: list[IEvent] = []
+        self.called = False
+
+    @property
+    def events(self) -> Sequence[IEvent]:
+        return self._evs.copy()
+
+    async def handle(self, event: SampleEvent) -> None:
+        self.called = True
+
+
+class _TestEventContainer:
+    """Minimal container for event fallback tests; implements Container protocol."""
+
+    def __init__(self) -> None:
+        self._primary = PrimaryEventHandler()
+        self._fallback = FallbackEventHandler()
+        self._external_container: Any = None
+
+    @property
+    def external_container(self) -> Any:
+        return self._external_container
+
+    def attach_external_container(self, container: Any) -> None:
+        self._external_container = container
+
+    async def resolve(self, type_: type[T]) -> T:
+        if type_ is PrimaryEventHandler:
+            return self._primary  # type: ignore[return-value]
+        if type_ is FallbackEventHandler:
+            return self._fallback  # type: ignore[return-value]
+        raise KeyError(type_)
+
+
+@pytest.mark.asyncio
+async def test_event_fallback_no_cb_primary_fails_uses_fallback() -> None:
+    event_map: EventMap = EventMap()
+    event_map.bind(
+        SampleEvent,
+        EventHandlerFallback(PrimaryEventHandler, FallbackEventHandler),
+    )
+    container: Container[Any] = _TestEventContainer()
+    emitter = EventEmitter(event_map=event_map, container=container)
+
+    follow_ups = await emitter.emit(SampleEvent(id="e1"))
+
+    assert container._primary.called
+    assert container._fallback.called
+    assert follow_ups == []
+
+
+@pytest.mark.asyncio
+async def test_event_fallback_failure_exceptions_only_matching_triggers_fallback() -> None:
+    event_map = EventMap()
+    event_map.bind(
+        SampleEvent,
+        EventHandlerFallback(
+            PrimaryEventHandler,
+            FallbackEventHandler,
+            failure_exceptions=(ValueError,),
+        ),
+    )
+    container: Container[Any] = _TestEventContainer()
+    emitter = EventEmitter(event_map=event_map, container=container)
+
+    with pytest.raises(RuntimeError, match="Primary failed"):
+        await emitter.emit(SampleEvent(id="e1"))
+
+    assert container._primary.called
+    assert not container._fallback.called
+
+
+@pytest.mark.asyncio
+async def test_event_fallback_matching_filter_triggers_fallback() -> None:
+    """When failure_exceptions matches the primary error, fallback is invoked."""
+    event_map: EventMap = EventMap()
+    event_map.bind(
+        SampleEvent,
+        EventHandlerFallback(
+            PrimaryEventHandler,
+            FallbackEventHandler,
+            failure_exceptions=(RuntimeError,),
+        ),
+    )
+    container: Container[Any] = _TestEventContainer()
+    emitter = EventEmitter(event_map=event_map, container=container)
+
+    follow_ups = await emitter.emit(SampleEvent(id="e1"))
+
+    assert container._primary.called
+    assert container._fallback.called
+    assert follow_ups == []
+
+
+# --- Validation tests ---
+
+
+def test_event_fallback_validation_same_event_type_accepts() -> None:
+    """Same event type is accepted."""
+    EventHandlerFallback(PrimaryEventHandler, FallbackEventHandler)
+
+
+def test_event_fallback_validation_different_event_type_raises() -> None:
+    """Different event types raise TypeError."""
+    from cqrs.events.event import DomainEvent
+
+    class OtherEvent(DomainEvent, frozen=True):
+        num: int
+
+    class HandlerOther(EventHandler[OtherEvent]):
+        async def handle(self, event: OtherEvent) -> None:
+            pass
+
+    with pytest.raises(TypeError, match="same event type"):
+        EventHandlerFallback(PrimaryEventHandler, HandlerOther)
+
+
+def test_event_fallback_validation_not_classes_raises() -> None:
+    """Passing non-classes raises TypeError."""
+    with pytest.raises(TypeError, match="must be handler classes"):
+        EventHandlerFallback(PrimaryEventHandler, FallbackEventHandler())  # type: ignore[arg-type]
+    with pytest.raises(TypeError, match="must be handler classes"):
+        EventHandlerFallback(PrimaryEventHandler(), FallbackEventHandler)  # type: ignore[arg-type]
+
+
+def test_event_fallback_validation_primary_not_event_handler_raises() -> None:
+    """Primary that is not EventHandler subclass raises TypeError."""
+    from cqrs.requests.request import Request
+    from cqrs.requests.request_handler import RequestHandler
+    from cqrs.response import Response
+
+    class NotAnEventHandler:
+        pass
+
+    class SomeHandler(RequestHandler[Request, Response]):
+        async def handle(self, request: Request) -> Response:
+            raise NotImplementedError
+
+    with pytest.raises(TypeError, match="primary.*must be a subclass of EventHandler"):
+        EventHandlerFallback(NotAnEventHandler, FallbackEventHandler)  # type: ignore[arg-type]
+    with pytest.raises(TypeError, match="primary.*must be a subclass of EventHandler"):
+        EventHandlerFallback(SomeHandler, FallbackEventHandler)  # pyright: ignore[reportArgumentType]
diff --git a/tests/unit/test_event_handler_events.py b/tests/unit/test_event_handler_events.py
new file mode 100644
index 0000000..d681fe2
--- /dev/null
+++ b/tests/unit/test_event_handler_events.py
@@ -0,0 +1,49 @@
+"""Unit tests for EventHandler.events() method (sync, default returns ())."""
+
+import pydantic
+
+from cqrs.events import DomainEvent, EventHandler
+from cqrs.events.event import IEvent
+
+
+class _TestEvent(DomainEvent, frozen=True):
+    """Test domain event."""
+
+    item_id: str = pydantic.Field()
+
+
+class _DefaultEventsHandler(EventHandler[_TestEvent]):
+    """Handler that does not override events()."""
+
+    async def handle(self, event: _TestEvent) -> None:
+        pass
+
+
+class _CustomEventsHandler(EventHandler[_TestEvent]):
+    """Handler that overrides events property and returns follow-up events."""
+
+    def __init__(self) -> None:
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> tuple[IEvent, ...]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: _TestEvent) -> None:
+        self._follow_ups.append(_TestEvent(item_id=f"follow_{event.item_id}"))
+
+
+async def test_event_handler_events_default_returns_empty() -> None:
+    """Arrange: handler with default events. Act: access events. Assert: returns ()."""
+    handler = _DefaultEventsHandler()
+    result = handler.events
+    assert result == ()
+
+
+async def test_event_handler_events_custom_returns_follow_ups() -> None:
+    """Arrange: handler that overrides events. Act: handle then access events. Assert: returns follow-ups."""
+    handler = _CustomEventsHandler()
+    await handler.handle(_TestEvent(item_id="1"))
+    result = handler.events
+    assert len(result) == 1
+    assert result[0].item_id == "follow_1"  # type: ignore[attr-defined]
diff --git a/tests/unit/test_event_notification_proto_hash.py b/tests/unit/test_event_notification_proto_hash.py
new file mode 100644
index 0000000..d2d27ee
--- /dev/null
+++ b/tests/unit/test_event_notification_proto_hash.py
@@ -0,0 +1,48 @@
+"""Tests for PydanticNotificationEvent proto(), from_proto(), and __hash__() methods."""
+
+import uuid
+
+import pytest
+
+from cqrs.events.event import PydanticNotificationEvent
+
+
+class SimplePydanticNotificationEvent(PydanticNotificationEvent[dict], frozen=True):
+    """Minimal Pydantic notification event for testing."""
+
+    event_name: str = "test.event"
+    payload: dict = {}
+
+
+class TestPydanticNotificationEventProtoAndHash:
+    """Test PydanticNotificationEvent proto(), from_proto(), and __hash__() methods."""
+
+    def test_proto_raises_not_implemented_error(self):
+        """PydanticNotificationEvent.proto() raises NotImplementedError by default."""
+        event = SimplePydanticNotificationEvent(
+            event_name="user.created",
+            payload={"user_id": "123"},
+        )
+        with pytest.raises(NotImplementedError, match="Method not implemented"):
+            event.proto()
+
+    def test_from_proto_raises_not_implemented_error(self):
+        """PydanticNotificationEvent.from_proto() raises NotImplementedError by default."""
+        with pytest.raises(NotImplementedError, match="Method not implemented"):
+            SimplePydanticNotificationEvent.from_proto(None)
+
+    def test_hash_returns_hash_of_event_id(self):
+        """PydanticNotificationEvent.__hash__() returns hash of event_id."""
+        event_id = uuid.uuid4()
+        event = SimplePydanticNotificationEvent(
+            event_name="user.created",
+            payload={"user_id": "123"},
+            event_id=event_id,
+        )
+        assert PydanticNotificationEvent.__hash__(event) == hash(event_id)
+        event2 = SimplePydanticNotificationEvent(
+            event_name="other",
+            payload={},
+            event_id=event_id,
+        )
+        assert PydanticNotificationEvent.__hash__(event) == PydanticNotificationEvent.__hash__(event2)
diff --git a/tests/unit/test_event_processor.py b/tests/unit/test_event_processor.py
index 3415c89..dc54117 100644
--- a/tests/unit/test_event_processor.py
+++ b/tests/unit/test_event_processor.py
@@ -3,6 +3,7 @@
 
 import pydantic
 
+from cqrs import Event
 from cqrs.events import (
     DomainEvent,
     EventEmitter,
@@ -49,20 +50,27 @@ async def test_event_processor_processes_events_parallel() -> None:
     event_map.bind(_TestDomainEvent, _TestEventHandler)
     container = Container(event_handler)
 
-    processor = EventProcessor(
+    event_emitter = EventEmitter(
         event_map=event_map,
         container=container,  # type: ignore
+    )
+
+    processor = EventProcessor(
+        event_map=event_map,
+        event_emitter=event_emitter,
         max_concurrent_event_handlers=2,
         concurrent_event_handle_enable=True,
     )
 
-    events = [
+    events: list[Event] = [
         _TestDomainEvent(item_id="1"),
         _TestDomainEvent(item_id="2"),
         _TestDomainEvent(item_id="3"),
     ]
+    await processor.emit_events(events)
 
-    await processor.process_events(events)  # type: ignore[arg-type]
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
 
     assert len(event_handler.processed_events) == 3
     assert all(event in event_handler.processed_events for event in events)
@@ -75,20 +83,25 @@ async def test_event_processor_processes_events_sequentially() -> None:
     event_map.bind(_TestDomainEvent, _TestEventHandler)
     container = Container(event_handler)
 
-    processor = EventProcessor(
+    event_emitter = EventEmitter(
         event_map=event_map,
         container=container,  # type: ignore
+    )
+
+    processor = EventProcessor(
+        event_map=event_map,
+        event_emitter=event_emitter,
         max_concurrent_event_handlers=2,
         concurrent_event_handle_enable=False,
     )
 
-    events = [
+    events: list[Event] = [
         _TestDomainEvent(item_id="1"),
         _TestDomainEvent(item_id="2"),
         _TestDomainEvent(item_id="3"),
     ]
 
-    await processor.process_events(events)  # type: ignore[arg-type]
+    await processor.emit_events(events)
 
     assert len(event_handler.processed_events) == 3
     assert all(event in event_handler.processed_events for event in events)
@@ -99,14 +112,12 @@ async def test_event_processor_processes_empty_events_list() -> None:
     event_handler = _TestEventHandler()
     event_map = EventMap()
     event_map.bind(_TestDomainEvent, _TestEventHandler)
-    container = Container(event_handler)
 
     processor = EventProcessor(
         event_map=event_map,
-        container=container,  # type: ignore
     )
 
-    await processor.process_events([])
+    await processor.emit_events([])
 
     assert len(event_handler.processed_events) == 0
 
@@ -114,14 +125,12 @@ async def test_event_processor_processes_empty_events_list() -> None:
 async def test_event_processor_emit_events_with_emitter() -> None:
     """Test that EventProcessor emits events via EventEmitter."""
     event_map = EventMap()
-    container = Container(_TestEventHandler())
 
     event_emitter = mock.AsyncMock(spec=EventEmitter)
-    event_emitter.emit = mock.AsyncMock()
+    event_emitter.emit = mock.AsyncMock(return_value=())
 
     processor = EventProcessor(
         event_map=event_map,
-        container=container,  # type: ignore
         event_emitter=event_emitter,
     )
 
@@ -133,25 +142,25 @@ async def test_event_processor_emit_events_with_emitter() -> None:
     events_copy = events.copy()
     await processor.emit_events(events_copy)  # type: ignore[arg-type]  # type: ignore[arg-type]
 
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert event_emitter.emit.call_count == 2
-    # Check that events were passed to emit (order may vary due to pop)
+    # Check that events were passed to emit (order may vary)
     emitted_events = [call[0][0] for call in event_emitter.emit.call_args_list]
     assert events[0] in emitted_events
     assert events[1] in emitted_events
-    # Events should be popped from the list (internal copy is modified)
-    assert len(events_copy) == 0
     # Original list should remain unchanged
     assert len(events) == 2
+    assert len(events_copy) == 2
 
 
 async def test_event_processor_emit_events_without_emitter() -> None:
     """Test that EventProcessor does nothing when EventEmitter is None."""
     event_map = EventMap()
-    container = Container(_TestEventHandler())
 
     processor = EventProcessor(
         event_map=event_map,
-        container=container,  # type: ignore
         event_emitter=None,
     )
 
@@ -171,12 +180,14 @@ async def test_event_processor_process_and_emit_events() -> None:
     event_map.bind(_TestDomainEvent, _TestEventHandler)
     container = Container(event_handler)
 
-    event_emitter = mock.AsyncMock(spec=EventEmitter)
-    event_emitter.emit = mock.AsyncMock()
+    # Create real EventEmitter to process events, but wrap message_broker with mock
+    event_emitter = EventEmitter(
+        event_map=event_map,
+        container=container,  # type: ignore
+    )
 
     processor = EventProcessor(
         event_map=event_map,
-        container=container,  # type: ignore
         event_emitter=event_emitter,
         max_concurrent_event_handlers=2,
         concurrent_event_handle_enable=True,
@@ -187,12 +198,13 @@ async def test_event_processor_process_and_emit_events() -> None:
         _TestDomainEvent(item_id="2"),
     ]
 
-    await processor.process_and_emit_events(events.copy())  # type: ignore[arg-type]  # type: ignore[arg-type]
+    await processor.emit_events(events)  # type: ignore[arg-type]  # type: ignore[arg-type]
+
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
 
     # Events should be processed
     assert len(event_handler.processed_events) == 2
-    # Events should be emitted
-    assert event_emitter.emit.call_count == 2
     # Original list should not be modified (copy is used internally)
     assert len(events) == 2
 
@@ -226,44 +238,119 @@ async def handle(self, event: _TestDomainEvent) -> None:
     event_map.bind(_TestDomainEvent, TrackingEventHandler)
     container = Container(event_handler)  # type: ignore
 
+    event_emitter = EventEmitter(
+        event_map=event_map,
+        container=container,  # type: ignore
+    )
+
     # Use semaphore limit of 2
     processor = EventProcessor(
         event_map=event_map,
-        container=container,  # type: ignore
+        event_emitter=event_emitter,
         max_concurrent_event_handlers=2,
         concurrent_event_handle_enable=True,
     )
 
     events = [_TestDomainEvent(item_id=str(i)) for i in range(5)]
+    await processor.emit_events(events)  # type: ignore[arg-type]
 
-    await processor.process_events(events)  # type: ignore[arg-type]
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.2)
 
     # Max concurrent should not exceed semaphore limit (2)
     assert max_concurrent <= 2
     assert len(event_handler.processed_events) == 5
 
 
-async def test_event_processor_with_middleware_chain() -> None:
-    """Test that EventProcessor works with middleware chain."""
-    from cqrs.middlewares.base import MiddlewareChain
+async def test_event_processor_follow_ups_sequential_bfs() -> None:
+    """Arrange: handler that returns follow-up events. Act: emit_events sequential. Assert: follow-ups processed (BFS)."""
 
-    event_handler = _TestEventHandler()
-    event_map = EventMap()
-    event_map.bind(_TestDomainEvent, _TestEventHandler)
-    container = Container(event_handler)
+    class _ChainedEvent(DomainEvent, frozen=True):
+        level: int = pydantic.Field()
+        seq: int = pydantic.Field()
+
+    processed: list[_ChainedEvent] = []
 
-    middleware_chain = MiddlewareChain()
+    class _ChainedHandler(EventHandler[_ChainedEvent]):
+        @property
+        def events(self) -> tuple[_ChainedEvent, ...]:
+            if not self._last or self._last.level >= 2:
+                return ()
+            return (_ChainedEvent(level=self._last.level + 1, seq=self._last.seq),)
+
+        def __init__(self) -> None:
+            self._last: _ChainedEvent | None = None
 
+        async def handle(self, event: _ChainedEvent) -> None:
+            self._last = event
+            processed.append(event)
+
+    handler = _ChainedHandler()
+    event_map = EventMap()
+    event_map.bind(_ChainedEvent, _ChainedHandler)
+    container = Container(handler)  # type: ignore[arg-type]
+    emitter = EventEmitter(event_map=event_map, container=container)  # type: ignore[arg-type]
     processor = EventProcessor(
         event_map=event_map,
-        container=container,  # type: ignore
-        middleware_chain=middleware_chain,
+        event_emitter=emitter,
+        concurrent_event_handle_enable=False,
     )
+    await processor.emit_events([_ChainedEvent(level=0, seq=1)])
+    assert len(processed) == 3  # level 0 -> 1 -> 2
+    assert processed[0].level == 0 and processed[1].level == 1 and processed[2].level == 2
 
-    events = [
-        _TestDomainEvent(item_id="1"),
-    ]
 
-    await processor.process_events(events)  # type: ignore[arg-type]
+async def test_event_processor_follow_ups_parallel_under_semaphore() -> None:
+    """Arrange: handler returns 3 follow-ups, semaphore 2. Act: emit one event. Assert: all 4 processed, max concurrent <= 2."""
+
+    class _FanEvent(DomainEvent, frozen=True):
+        id_: str = pydantic.Field(alias="id")
+        model_config = pydantic.ConfigDict(populate_by_name=True)
+
+    concurrent_count = 0
+    max_concurrent = 0
+    lock = asyncio.Lock()
+    processed: list[_FanEvent] = []
+
+    class _FanHandler(EventHandler[_FanEvent]):
+        def __init__(self) -> None:
+            self._follow_ups: list[_FanEvent] = []
+
+        @property
+        def events(self) -> tuple[_FanEvent, ...]:
+            return tuple(self._follow_ups)
 
-    assert len(event_handler.processed_events) == 1
+        async def handle(self, event: _FanEvent) -> None:
+            nonlocal concurrent_count, max_concurrent
+            self._follow_ups = []
+            if event.id_ == "root":
+                self._follow_ups = [
+                    _FanEvent(id="c1"),
+                    _FanEvent(id="c2"),
+                    _FanEvent(id="c3"),
+                ]
+            async with lock:
+                concurrent_count += 1
+                max_concurrent = max(max_concurrent, concurrent_count)
+            await asyncio.sleep(0.02)
+            async with lock:
+                concurrent_count -= 1
+            processed.append(event)
+            # Clear after handle so emitter always sees follow-ups from this run only
+            if event.id_ != "root":
+                self._follow_ups = []
+
+    handler = _FanHandler()
+    event_map = EventMap()
+    event_map.bind(_FanEvent, _FanHandler)
+    container = Container(handler)  # type: ignore[arg-type]
+    emitter = EventEmitter(event_map=event_map, container=container)  # type: ignore[arg-type]
+    processor = EventProcessor(
+        event_map=event_map,
+        event_emitter=emitter,
+        max_concurrent_event_handlers=2,
+        concurrent_event_handle_enable=True,
+    )
+    await processor.emit_events([_FanEvent(id="root")])
+    assert len(processed) == 4
+    assert max_concurrent <= 2
diff --git a/tests/unit/test_events_bootstrap.py b/tests/unit/test_events_bootstrap.py
new file mode 100644
index 0000000..b5334d3
--- /dev/null
+++ b/tests/unit/test_events_bootstrap.py
@@ -0,0 +1,239 @@
+"""
+AAA unit tests for cqrs.events.bootstrap.
+
+Covers setup_mediator and bootstrap for EventMediator (increased coverage).
+"""
+
+import typing
+
+import di
+
+import cqrs
+from cqrs import events
+from cqrs.container import di as di_container_impl
+from cqrs.middlewares import base as mediator_middlewares, logging as logging_middleware
+from cqrs.events import bootstrap
+
+
+# ---------------------------------------------------------------------------
+# Mock CQRSContainer for tests passing CQRSContainer (not di.Container)
+# ---------------------------------------------------------------------------
+
+
+class MockCQRSContainer:
+    """Minimal CQRSContainer implementation for bootstrap tests."""
+
+    def __init__(self) -> None:
+        self._external_container: typing.Any = None
+
+    @property
+    def external_container(self) -> typing.Any:
+        return self._external_container
+
+    def attach_external_container(self, container: typing.Any) -> None:
+        self._external_container = container
+
+    async def resolve(self, type_: type[typing.Any]) -> typing.Any:
+        return type_()
+
+
+# Stub event/handler for events_mapper (EventMap.bind)
+class _StubEvent(events.DomainEvent, frozen=True):
+    pass
+
+
+class _StubEventHandler(events.EventHandler[_StubEvent]):
+    async def handle(self, event: _StubEvent) -> None:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Test setup_mediator (events)
+# ---------------------------------------------------------------------------
+
+
+class TestSetupMediatorEvents:
+    """AAA tests for events.bootstrap.setup_mediator."""
+
+    def test_setup_mediator_returns_event_mediator(self) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        middlewares: list[mediator_middlewares.Middleware] = [
+            logging_middleware.LoggingMiddleware(),
+        ]
+
+        # Act
+        mediator = bootstrap.setup_mediator(
+            container,
+            middlewares=middlewares,
+        )
+
+        # Assert
+        assert isinstance(mediator, cqrs.EventMediator)
+        assert mediator._dispatcher is not None
+        assert mediator._dispatcher._container is container
+        assert mediator._dispatcher._event_map is not None
+
+    def test_setup_mediator_with_events_mapper_registers_handlers(self) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        middlewares = [logging_middleware.LoggingMiddleware()]
+        event_map_received: list[events.EventMap] = []
+
+        def events_mapper(m: events.EventMap) -> None:
+            event_map_received.append(m)
+            m.bind(_StubEvent, _StubEventHandler)
+
+        # Act
+        mediator = bootstrap.setup_mediator(
+            container,
+            middlewares=middlewares,
+            events_mapper=events_mapper,
+        )
+
+        # Assert
+        assert len(event_map_received) == 1
+        assert mediator._dispatcher._event_map is event_map_received[0]
+
+    def test_setup_mediator_with_cqrs_container(self) -> None:
+        # Arrange
+        container = MockCQRSContainer()
+        middlewares = [logging_middleware.LoggingMiddleware()]
+
+        # Act
+        mediator = bootstrap.setup_mediator(
+            container,
+            middlewares=middlewares,
+        )
+
+        # Assert
+        assert isinstance(mediator, cqrs.EventMediator)
+        assert mediator._dispatcher._container is container
+
+    def test_setup_mediator_without_events_mapper_uses_empty_map(self) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        middlewares = [logging_middleware.LoggingMiddleware()]
+
+        # Act
+        mediator = bootstrap.setup_mediator(
+            container,
+            middlewares=middlewares,
+        )
+
+        # Assert
+        assert len(mediator._dispatcher._event_map) == 0
+
+
+# ---------------------------------------------------------------------------
+# Test bootstrap (events)
+# ---------------------------------------------------------------------------
+
+
+class TestBootstrapEvents:
+    """AAA tests for events.bootstrap.bootstrap."""
+
+    def test_bootstrap_with_di_container_returns_event_mediator(self) -> None:
+        # Arrange
+        di_container = di.Container()
+
+        # Act
+        mediator = bootstrap.bootstrap(di_container=di_container)
+
+        # Assert
+        assert isinstance(mediator, cqrs.EventMediator)
+        assert mediator._dispatcher is not None
+
+    def test_bootstrap_with_cqrs_container_returns_event_mediator(self) -> None:
+        # Arrange
+        container = MockCQRSContainer()
+
+        # Act
+        mediator = bootstrap.bootstrap(di_container=container)
+
+        # Assert
+        assert isinstance(mediator, cqrs.EventMediator)
+        assert mediator._dispatcher._container is container
+
+    def test_bootstrap_calls_on_startup_callables(self) -> None:
+        # Arrange
+        di_container = di.Container()
+        on_startup_called: list[int] = []
+
+        def on_startup_1() -> None:
+            on_startup_called.append(1)
+
+        def on_startup_2() -> None:
+            on_startup_called.append(2)
+
+        # Act
+        bootstrap.bootstrap(
+            di_container=di_container,
+            on_startup=[on_startup_1, on_startup_2],
+        )
+
+        # Assert
+        assert on_startup_called == [1, 2]
+
+    def test_bootstrap_with_on_startup_none_does_not_fail(self) -> None:
+        # Arrange
+        di_container = di.Container()
+
+        # Act & Assert (no exception)
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            on_startup=None,
+        )
+        assert isinstance(mediator, cqrs.EventMediator)
+
+    def test_bootstrap_appends_logging_middleware_if_not_present(self) -> None:
+        # Arrange
+        di_container = di.Container()
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            middlewares=[],
+        )
+
+        # Assert
+        assert mediator._dispatcher._middleware_chain is not None
+        assert isinstance(mediator, cqrs.EventMediator)
+
+    def test_bootstrap_with_existing_logging_middleware_does_not_duplicate(
+        self,
+    ) -> None:
+        # Arrange
+        di_container = di.Container()
+        middlewares = [logging_middleware.LoggingMiddleware()]
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            middlewares=middlewares,
+        )
+
+        # Assert
+        assert isinstance(mediator, cqrs.EventMediator)
+
+    def test_bootstrap_with_events_mapper(self) -> None:
+        # Arrange
+        di_container = di.Container()
+        events_map_received: list[events.EventMap] = []
+
+        def events_mapper(m: events.EventMap) -> None:
+            events_map_received.append(m)
+            m.bind(_StubEvent, _StubEventHandler)
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            events_mapper=events_mapper,
+        )
+
+        # Assert
+        assert len(events_map_received) == 1
+        assert mediator._dispatcher._event_map is events_map_received[0]
diff --git a/tests/unit/test_multi_level_events_parameterized.py b/tests/unit/test_multi_level_events_parameterized.py
new file mode 100644
index 0000000..85fc31a
--- /dev/null
+++ b/tests/unit/test_multi_level_events_parameterized.py
@@ -0,0 +1,296 @@
+"""Unit tests: multi-level event handling (follow-ups) for all handler/mediator types.
+
+All tests are parameterized by parallel (True/False) where applicable.
+Expected result is the same in both modes: all events must be processed.
+"""
+
+import asyncio
+import typing
+
+import di
+import pydantic
+import pytest
+
+import cqrs
+from cqrs.events import DomainEvent, EventEmitter, EventHandler, EventMap
+from cqrs.events.event import IEvent
+from cqrs.events.event_processor import EventProcessor
+from cqrs.dispatcher.event import EventDispatcher
+from cqrs.container.protocol import Container
+from cqrs.requests import bootstrap
+
+
+# ---- EventProcessor: 1 root -> 3 children (4 events total) ----
+
+
+class _FanEvent(DomainEvent, frozen=True):
+    id_: str = pydantic.Field(alias="id")
+    model_config = pydantic.ConfigDict(populate_by_name=True)
+
+
+class _FanHandler(EventHandler[_FanEvent]):
+    def __init__(self) -> None:
+        self._follow_ups: list[_FanEvent] = []
+
+    @property
+    def events(self) -> tuple[_FanEvent, ...]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: _FanEvent) -> None:
+        self._follow_ups = []
+        if event.id_ == "root":
+            self._follow_ups = [
+                _FanEvent(id="c1"),
+                _FanEvent(id="c2"),
+                _FanEvent(id="c3"),
+            ]
+        if event.id_ != "root":
+            self._follow_ups = []
+
+
+class _FanContainer(Container[object]):
+    def __init__(self, handler: _FanHandler) -> None:
+        self._handler = handler
+        self._external: object | None = None
+
+    @property
+    def external_container(self) -> object:
+        return self._external  # type: ignore[return-value]
+
+    def attach_external_container(self, container: object) -> None:
+        self._external = container
+
+    async def resolve(self, type_: type) -> EventHandler[IEvent]:
+        if type_ is _FanHandler:
+            return self._handler  # type: ignore[return-value]
+        raise KeyError(type_)
+
+
+@pytest.mark.parametrize("parallel", [True, False])
+async def test_event_processor_multi_level_all_events_processed(parallel: bool) -> None:
+    """EventProcessor: root -> 3 children. Parallel or sequential: all 4 events must be processed."""
+    processed: list[_FanEvent] = []
+    handler = _FanHandler()
+    original_handle = handler.handle
+
+    async def tracking_handle(event: _FanEvent) -> None:
+        await original_handle(event)
+        processed.append(event)
+
+    handler.handle = tracking_handle  # type: ignore[method-assign]
+
+    event_map = EventMap()
+    event_map.bind(_FanEvent, _FanHandler)
+    container = _FanContainer(handler)
+    emitter = EventEmitter(event_map=event_map, container=container)
+    processor = EventProcessor(
+        event_map=event_map,
+        event_emitter=emitter,
+        max_concurrent_event_handlers=2,
+        concurrent_event_handle_enable=parallel,
+    )
+    await processor.emit_events([_FanEvent(id="root")])
+    if parallel:
+        await asyncio.sleep(0.15)
+    assert len(processed) == 4
+    ids = {e.id_ for e in processed}
+    assert ids == {"root", "c1", "c2", "c3"}
+
+
+# ---- EventDispatcher: 3-level chain L1 -> L2 -> L3 (always sequential) ----
+
+
+class _EventL1(DomainEvent, frozen=True):
+    name: str = pydantic.Field()
+
+
+class _EventL2(DomainEvent, frozen=True):
+    name: str = pydantic.Field()
+
+
+class _EventL3(DomainEvent, frozen=True):
+    name: str = pydantic.Field()
+
+
+class _HandlerL1(EventHandler[_EventL1]):
+    def __init__(self) -> None:
+        self.processed: list[_EventL1] = []
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> tuple[IEvent, ...]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: _EventL1) -> None:
+        self.processed.append(event)
+        self._follow_ups = [_EventL2(name="L2_from_" + event.name)]
+
+
+class _HandlerL2(EventHandler[_EventL2]):
+    def __init__(self) -> None:
+        self.processed: list[_EventL2] = []
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> tuple[IEvent, ...]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: _EventL2) -> None:
+        self.processed.append(event)
+        self._follow_ups = [_EventL3(name="L3_from_" + event.name)]
+
+
+class _HandlerL3(EventHandler[_EventL3]):
+    def __init__(self) -> None:
+        self.processed: list[_EventL3] = []
+
+    async def handle(self, event: _EventL3) -> None:
+        self.processed.append(event)
+
+
+class _DispatcherContainer(Container[object]):
+    def __init__(self) -> None:
+        self._h1 = _HandlerL1()
+        self._h2 = _HandlerL2()
+        self._h3 = _HandlerL3()
+        self._external: object | None = None
+
+    @property
+    def external_container(self) -> object:
+        return self._external  # type: ignore[return-value]
+
+    def attach_external_container(self, container: object) -> None:
+        self._external = container
+
+    async def resolve(self, type_: type) -> EventHandler[IEvent]:
+        if type_ is _HandlerL1:
+            return self._h1  # type: ignore[return-value]
+        if type_ is _HandlerL2:
+            return self._h2  # type: ignore[return-value]
+        if type_ is _HandlerL3:
+            return self._h3  # type: ignore[return-value]
+        raise KeyError(type_)
+
+
+@pytest.mark.parametrize("parallel", [False])
+async def test_event_dispatcher_multi_level_all_events_processed(parallel: bool) -> None:
+    """EventDispatcher: L1 -> L2 -> L3. Dispatcher is always sequential; all 3 levels must be processed."""
+    event_map = EventMap()
+    event_map.bind(_EventL1, _HandlerL1)
+    event_map.bind(_EventL2, _HandlerL2)
+    event_map.bind(_EventL3, _HandlerL3)
+    container = _DispatcherContainer()
+    dispatcher = EventDispatcher(event_map=event_map, container=container)
+    await dispatcher.dispatch(_EventL1(name="a"))
+    assert len(container._h1.processed) == 1
+    assert container._h1.processed[0].name == "a"
+    assert len(container._h2.processed) == 1
+    assert container._h2.processed[0].name == "L2_from_a"
+    assert len(container._h3.processed) == 1
+    assert container._h3.processed[0].name == "L3_from_L2_from_a"
+
+
+# ---- RequestMediator (bootstrap): 3-level chain L1 -> L2 -> L3 ----
+
+_MEDIATOR_PROCESSED_L1: list[cqrs.DomainEvent] = []
+_MEDIATOR_PROCESSED_L2: list[cqrs.DomainEvent] = []
+_MEDIATOR_PROCESSED_L3: list[cqrs.DomainEvent] = []
+
+
+class _EmitL1Command(cqrs.Request):
+    seed: str = pydantic.Field()
+
+
+class _MediatorEventL1(cqrs.DomainEvent, frozen=True):
+    level: int = 1
+    seed: str = pydantic.Field()
+
+
+class _MediatorEventL2(cqrs.DomainEvent, frozen=True):
+    level: int = 2
+    seed: str = pydantic.Field()
+
+
+class _MediatorEventL3(cqrs.DomainEvent, frozen=True):
+    level: int = 3
+    seed: str = pydantic.Field()
+
+
+class _EmitL1CommandHandler(cqrs.RequestHandler[_EmitL1Command, None]):
+    def __init__(self) -> None:
+        self._events: list[IEvent] = []
+
+    @property
+    def events(self) -> typing.Sequence[IEvent]:
+        return tuple(self._events)
+
+    async def handle(self, request: _EmitL1Command) -> None:
+        self._events.append(_MediatorEventL1(seed=request.seed))
+
+
+class _MediatorHandlerL1(cqrs.EventHandler[_MediatorEventL1]):
+    def __init__(self) -> None:
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> typing.Sequence[IEvent]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: _MediatorEventL1) -> None:
+        _MEDIATOR_PROCESSED_L1.append(event)
+        self._follow_ups.append(_MediatorEventL2(seed=event.seed))
+
+
+class _MediatorHandlerL2(cqrs.EventHandler[_MediatorEventL2]):
+    def __init__(self) -> None:
+        self._follow_ups: list[IEvent] = []
+
+    @property
+    def events(self) -> typing.Sequence[IEvent]:
+        return tuple(self._follow_ups)
+
+    async def handle(self, event: _MediatorEventL2) -> None:
+        _MEDIATOR_PROCESSED_L2.append(event)
+        self._follow_ups.append(_MediatorEventL3(seed=event.seed))
+
+
+class _MediatorHandlerL3(cqrs.EventHandler[_MediatorEventL3]):
+    async def handle(self, event: _MediatorEventL3) -> None:
+        _MEDIATOR_PROCESSED_L3.append(event)
+
+
+def _commands_mapper(mapper: cqrs.RequestMap) -> None:
+    mapper.bind(_EmitL1Command, _EmitL1CommandHandler)
+
+
+def _events_mapper(mapper: cqrs.EventMap) -> None:
+    mapper.bind(_MediatorEventL1, _MediatorHandlerL1)
+    mapper.bind(_MediatorEventL2, _MediatorHandlerL2)
+    mapper.bind(_MediatorEventL3, _MediatorHandlerL3)
+
+
+@pytest.mark.parametrize("parallel", [True, False])
+async def test_request_mediator_multi_level_all_events_processed(parallel: bool) -> None:
+    """RequestMediator: command emits L1 -> L2 -> L3. Parallel or sequential: all 3 levels must be processed."""
+    _MEDIATOR_PROCESSED_L1.clear()
+    _MEDIATOR_PROCESSED_L2.clear()
+    _MEDIATOR_PROCESSED_L3.clear()
+
+    mediator = bootstrap.bootstrap(
+        di_container=di.Container(),
+        commands_mapper=_commands_mapper,
+        domain_events_mapper=_events_mapper,
+        max_concurrent_event_handlers=2,
+        concurrent_event_handle_enable=parallel,
+    )
+
+    await mediator.send(_EmitL1Command(seed="x"))
+    if parallel:
+        await asyncio.sleep(0.15)
+
+    assert len(_MEDIATOR_PROCESSED_L1) == 1
+    assert _MEDIATOR_PROCESSED_L1[0].seed == "x"  # type: ignore[attr-defined]
+    assert len(_MEDIATOR_PROCESSED_L2) == 1
+    assert _MEDIATOR_PROCESSED_L2[0].seed == "x"  # type: ignore[attr-defined]
+    assert len(_MEDIATOR_PROCESSED_L3) == 1
+    assert _MEDIATOR_PROCESSED_L3[0].seed == "x"  # type: ignore[attr-defined]
diff --git a/tests/unit/test_request_fallback.py b/tests/unit/test_request_fallback.py
new file mode 100644
index 0000000..03b19d2
--- /dev/null
+++ b/tests/unit/test_request_fallback.py
@@ -0,0 +1,261 @@
+"""Tests for RequestHandlerFallback (without circuit breaker)."""
+
+from typing import Any, TypeVar
+
+import pytest
+
+from cqrs import RequestHandlerFallback
+from cqrs.container.protocol import Container
+from cqrs.dispatcher import RequestDispatcher
+from cqrs.events.event import IEvent
+from cqrs.requests.map import RequestMap
+from cqrs.requests.request import Request
+from cqrs.requests.request_handler import RequestHandler
+from cqrs.response import Response
+
+T = TypeVar("T")
+
+
+class SimpleCommand(Request):
+    value: str
+
+
+class SimpleResult(Response):
+    value: str
+
+
+class PrimaryHandler(RequestHandler[SimpleCommand, SimpleResult]):
+    def __init__(self) -> None:
+        self._events: list[IEvent] = []
+        self.called = False
+
+    @property
+    def events(self) -> list[IEvent]:
+        return self._events.copy()
+
+    async def handle(self, request: SimpleCommand) -> SimpleResult:
+        self.called = True
+        raise RuntimeError("Primary failed")
+
+
+class FallbackHandler(RequestHandler[SimpleCommand, SimpleResult]):
+    def __init__(self) -> None:
+        self._events: list[IEvent] = []
+        self.called = False
+
+    @property
+    def events(self) -> list[IEvent]:
+        return self._events.copy()
+
+    async def handle(self, request: SimpleCommand) -> SimpleResult:
+        self.called = True
+        return SimpleResult(value=f"fallback:{request.value}")
+
+
+class _TestRequestContainer(Container[Any]):
+    """Minimal container for request fallback tests."""
+
+    def __init__(self) -> None:
+        self._primary = PrimaryHandler()
+        self._fallback = FallbackHandler()
+        self._external_container: Any = None
+
+    @property
+    def external_container(self) -> Any:
+        return self._external_container
+
+    def attach_external_container(self, container: Any) -> None:
+        self._external_container = container
+
+    async def resolve(self, type_: type[T]) -> T:
+        if type_ is PrimaryHandler:
+            return self._primary  # type: ignore[return-value]
+        if type_ is FallbackHandler:
+            return self._fallback  # type: ignore[return-value]
+        raise KeyError(type_)
+
+
+@pytest.mark.asyncio
+async def test_request_fallback_no_cb_primary_fails_uses_fallback() -> None:
+    request_map: RequestMap = RequestMap()
+    request_map.bind(
+        SimpleCommand,
+        RequestHandlerFallback(PrimaryHandler, FallbackHandler),
+    )
+    container: Container[Any] = _TestRequestContainer()
+    dispatcher = RequestDispatcher(request_map=request_map, container=container)
+
+    result = await dispatcher.dispatch(SimpleCommand(value="x"))
+
+    assert result.response.value == "fallback:x"
+    assert container._primary.called
+    assert container._fallback.called
+
+
+@pytest.mark.asyncio
+async def test_request_fallback_failure_exceptions_only_matching_triggers_fallback() -> None:
+    request_map = RequestMap()
+    request_map.bind(
+        SimpleCommand,
+        RequestHandlerFallback(
+            PrimaryHandler,
+            FallbackHandler,
+            failure_exceptions=(ValueError,),
+        ),
+    )
+    container: Container[Any] = _TestRequestContainer()
+    dispatcher = RequestDispatcher(request_map=request_map, container=container)
+
+    with pytest.raises(RuntimeError, match="Primary failed"):
+        await dispatcher.dispatch(SimpleCommand(value="x"))
+
+    assert container._primary.called
+    assert not container._fallback.called
+
+
+@pytest.mark.asyncio
+async def test_request_fallback_primary_succeeds_fallback_not_invoked() -> None:
+    """When the primary handler succeeds, the fallback is not invoked."""
+
+    class SuccessPrimaryHandler(RequestHandler[SimpleCommand, SimpleResult]):
+        def __init__(self) -> None:
+            self._events: list[IEvent] = []
+            self.called = False
+
+        @property
+        def events(self) -> list[IEvent]:
+            return self._events.copy()
+
+        async def handle(self, request: SimpleCommand) -> SimpleResult:
+            self.called = True
+            return SimpleResult(value=f"primary:{request.value}")
+
+    class UnusedFallbackHandler(RequestHandler[SimpleCommand, SimpleResult]):
+        def __init__(self) -> None:
+            self._events: list[IEvent] = []
+            self.called = False
+
+        @property
+        def events(self) -> list[IEvent]:
+            return self._events.copy()
+
+        async def handle(self, request: SimpleCommand) -> SimpleResult:
+            self.called = True
+            return SimpleResult(value="unused")
+
+    class SuccessContainer(Container[Any]):
+        def __init__(self) -> None:
+            self._primary = SuccessPrimaryHandler()
+            self._fallback = UnusedFallbackHandler()
+            self._external_container: Any = None
+
+        @property
+        def external_container(self) -> Any:
+            return self._external_container
+
+        def attach_external_container(self, container: Any) -> None:
+            self._external_container = container
+
+        async def resolve(self, type_: type[T]) -> T:
+            if type_ is SuccessPrimaryHandler:
+                return self._primary  # type: ignore[return-value]
+            if type_ is UnusedFallbackHandler:
+                return self._fallback  # type: ignore[return-value]
+            raise KeyError(type_)
+
+    request_map = RequestMap()
+    request_map.bind(
+        SimpleCommand,
+        RequestHandlerFallback(SuccessPrimaryHandler, UnusedFallbackHandler),
+    )
+    container = SuccessContainer()
+    dispatcher = RequestDispatcher(request_map=request_map, container=container)
+
+    result = await dispatcher.dispatch(SimpleCommand(value="ok"))
+
+    assert result.response.value == "primary:ok"
+    assert container._primary.called
+    assert not container._fallback.called
+
+
+# --- Validation tests ---
+
+
+def test_request_fallback_validation_same_request_and_response_types_accepts() -> None:
+    """Same request and response types (including None) are accepted."""
+    RequestHandlerFallback(PrimaryHandler, FallbackHandler)
+
+
+def test_request_fallback_validation_different_request_type_raises() -> None:
+    """Different request types raise TypeError."""
+    from cqrs.requests.request import Request
+    from cqrs.response import Response
+
+    class OtherCommand(Request):
+        value: int
+
+    class OtherResult(Response):
+        value: int
+
+    class FallbackOther(RequestHandler[OtherCommand, OtherResult]):
+        async def handle(self, request: OtherCommand) -> OtherResult:
+            return OtherResult(value=0)
+
+    with pytest.raises(TypeError, match="same request type"):
+        RequestHandlerFallback(PrimaryHandler, FallbackOther)
+
+
+def test_request_fallback_validation_different_response_type_raises() -> None:
+    """Different response types raise TypeError."""
+    from cqrs.response import Response
+
+    class OtherResult(Response):
+        value: int
+
+    class FallbackOtherResult(RequestHandler[SimpleCommand, OtherResult]):
+        async def handle(self, request: SimpleCommand) -> OtherResult:
+            return OtherResult(value=0)
+
+    with pytest.raises(TypeError, match="same response type"):
+        RequestHandlerFallback(PrimaryHandler, FallbackOtherResult)
+
+
+def test_request_fallback_validation_same_types_with_none_response_accepts() -> None:
+    """Both request and response (None) matching is accepted."""
+    from cqrs.requests.request import Request
+
+    class NoResultCommand(Request):
+        x: str
+
+    class PrimaryNoRes(RequestHandler[NoResultCommand, None]):
+        async def handle(self, request: NoResultCommand) -> None:
+            return None
+
+    class FallbackNoRes(RequestHandler[NoResultCommand, None]):
+        async def handle(self, request: NoResultCommand) -> None:
+            return None
+
+    RequestHandlerFallback(PrimaryNoRes, FallbackNoRes)
+
+
+def test_request_fallback_validation_not_classes_raises() -> None:
+    """Passing non-classes raises TypeError."""
+    with pytest.raises(TypeError, match="must be handler classes"):
+        RequestHandlerFallback(PrimaryHandler, FallbackHandler())  # type: ignore[arg-type]
+    with pytest.raises(TypeError, match="must be handler classes"):
+        RequestHandlerFallback(PrimaryHandler(), FallbackHandler)  # type: ignore[arg-type]
+
+
+def test_request_fallback_validation_mixed_handler_base_raises() -> None:
+    """Mixing RequestHandler and StreamingRequestHandler raises TypeError."""
+    from cqrs.requests.request_handler import StreamingRequestHandler
+
+    class StreamingPrimary(StreamingRequestHandler[SimpleCommand, SimpleResult]):
+        async def handle(self, request: SimpleCommand):
+            yield SimpleResult(value=request.value)
+
+        def clear_events(self) -> None:
+            pass
+
+    with pytest.raises(TypeError, match="same handler base type"):
+        RequestHandlerFallback(PrimaryHandler, StreamingPrimary)
diff --git a/tests/unit/test_request_mediator_parallel_events.py b/tests/unit/test_request_mediator_parallel_events.py
index 9c3c2ab..0101e44 100644
--- a/tests/unit/test_request_mediator_parallel_events.py
+++ b/tests/unit/test_request_mediator_parallel_events.py
@@ -1,8 +1,9 @@
+import asyncio
 import typing
-from unittest import mock
 
 import pydantic
 
+import cqrs
 from cqrs.events import (
     DomainEvent,
     Event,
@@ -26,7 +27,7 @@ def __init__(self) -> None:
         self._events: list[Event] = []
 
     @property
-    def events(self) -> list[Event]:
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
         return self._events.copy()
 
     def clear_events(self) -> None:
@@ -69,23 +70,23 @@ async def test_request_mediator_processes_events_parallel() -> None:
     event_map = EventMap()
     event_map.bind(ItemProcessedDomainEvent, ItemProcessedEventHandler)
 
-    class EventContainer:
-        def __init__(self, handler):
-            self._handler = handler
-            self._external_container: typing.Any = None
+    event_container = Container(event_handler)
 
-        @property
-        def external_container(self) -> typing.Any:
-            return self._external_container
+    event_emitter = EventEmitter(
+        event_map=event_map,
+        container=event_container,  # type: ignore
+    )
 
-        def attach_external_container(self, container: typing.Any) -> None:
-            self._external_container = container
+    # Track emit calls
+    original_emit = event_emitter.emit
+    emit_call_count = 0
 
-        async def resolve(self, type_: typing.Type[typing.Any]) -> typing.Any:
-            return self._handler
+    async def tracked_emit(event):
+        nonlocal emit_call_count
+        emit_call_count += 1
+        return await original_emit(event)
 
-    event_emitter = mock.AsyncMock(spec=EventEmitter)
-    event_emitter.emit = mock.AsyncMock()
+    event_emitter.emit = tracked_emit  # type: ignore[assignment]
 
     mediator = RequestMediator(
         request_map=request_map,
@@ -96,15 +97,15 @@ async def resolve(self, type_: typing.Type[typing.Any]) -> typing.Any:
         concurrent_event_handle_enable=True,
     )
 
-    mediator._event_processor._event_dispatcher._container = EventContainer(
-        event_handler,
-    )  # type: ignore
     request = ProcessItemsCommand(item_ids=["item1", "item2", "item3"])
     await mediator.send(request)
 
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert handler.called
     assert len(event_handler.processed_events) == 3
-    assert event_emitter.emit.call_count == 3
+    assert emit_call_count == 3
 
 
 async def test_request_mediator_processes_events_sequentially() -> None:
@@ -117,23 +118,23 @@ async def test_request_mediator_processes_events_sequentially() -> None:
     event_map = EventMap()
     event_map.bind(ItemProcessedDomainEvent, ItemProcessedEventHandler)
 
-    class EventContainer:
-        def __init__(self, handler):
-            self._handler = handler
-            self._external_container: typing.Any = None
+    event_container = Container(event_handler)
 
-        @property
-        def external_container(self) -> typing.Any:
-            return self._external_container
+    event_emitter = EventEmitter(
+        event_map=event_map,
+        container=event_container,  # type: ignore
+    )
 
-        def attach_external_container(self, container: typing.Any) -> None:
-            self._external_container = container
+    # Track emit calls
+    original_emit = event_emitter.emit
+    emit_call_count = 0
 
-        async def resolve(self, type_: typing.Type[typing.Any]) -> typing.Any:
-            return self._handler
+    async def tracked_emit(event):
+        nonlocal emit_call_count
+        emit_call_count += 1
+        return await original_emit(event)
 
-    event_emitter = mock.AsyncMock(spec=EventEmitter)
-    event_emitter.emit = mock.AsyncMock()
+    event_emitter.emit = tracked_emit  # type: ignore[assignment]
 
     mediator = RequestMediator(
         request_map=request_map,
@@ -144,13 +145,12 @@ async def resolve(self, type_: typing.Type[typing.Any]) -> typing.Any:
         concurrent_event_handle_enable=False,
     )
 
-    mediator._event_processor._event_dispatcher._container = EventContainer(
-        event_handler,
-    )  # type: ignore
-
     request = ProcessItemsCommand(item_ids=["item1", "item2", "item3"])
     await mediator.send(request)
 
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert handler.called
     assert len(event_handler.processed_events) == 3
-    assert event_emitter.emit.call_count == 3
+    assert emit_call_count == 3
diff --git a/tests/unit/test_requests_bootstrap.py b/tests/unit/test_requests_bootstrap.py
new file mode 100644
index 0000000..deafb41
--- /dev/null
+++ b/tests/unit/test_requests_bootstrap.py
@@ -0,0 +1,565 @@
+"""
+AAA unit tests for cqrs.requests.bootstrap.
+
+Covers setup_event_emitter, setup_mediator, bootstrap, setup_streaming_mediator,
+and bootstrap_streaming for increased coverage.
+"""
+
+import typing
+import di
+import pytest
+
+import cqrs
+from cqrs import events
+from cqrs.container import di as di_container_impl
+from cqrs.message_brokers import devnull
+from cqrs.middlewares import base as mediator_middlewares, logging as logging_middleware
+from cqrs.requests import bootstrap
+from cqrs.requests.map import RequestMap
+
+
+# ---------------------------------------------------------------------------
+# Mock CQRSContainer for tests passing CQRSContainer (not di.Container)
+# ---------------------------------------------------------------------------
+
+
+class MockCQRSContainer:
+    """Minimal CQRSContainer implementation for bootstrap tests."""
+
+    def __init__(self) -> None:
+        self._external_container: typing.Any = None
+
+    @property
+    def external_container(self) -> typing.Any:
+        return self._external_container
+
+    def attach_external_container(self, container: typing.Any) -> None:
+        self._external_container = container
+
+    async def resolve(self, type_: type[typing.Any]) -> typing.Any:
+        return type_()
+
+
+# Stub event/handler used to make EventMap non-empty (empty EventMap is falsy)
+class _StubEvent(events.DomainEvent, frozen=True):
+    pass
+
+
+class _StubEventHandler(events.EventHandler[_StubEvent]):
+    async def handle(self, event: _StubEvent) -> None:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Test setup_event_emitter
+# ---------------------------------------------------------------------------
+
+
+class TestSetupEventEmitter:
+    """AAA tests for bootstrap.setup_event_emitter."""
+
+    def test_setup_event_emitter_with_di_container_returns_event_emitter(self) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+
+        # Act
+        emitter = bootstrap.setup_event_emitter(container)
+
+        # Assert
+        assert isinstance(emitter, events.EventEmitter)
+        assert emitter._event_map is not None
+        assert emitter._container is container
+
+    def test_setup_event_emitter_with_custom_message_broker(self) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        broker = devnull.DevnullMessageBroker()
+
+        # Act
+        emitter = bootstrap.setup_event_emitter(
+            container,
+            message_broker=broker,
+        )
+
+        # Assert
+        assert emitter._message_broker is broker
+
+    def test_setup_event_emitter_with_domain_events_mapper_registers_handlers(
+        self,
+    ) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        event_map_received: list[events.EventMap] = []
+
+        def domain_events_mapper(m: events.EventMap) -> None:
+            event_map_received.append(m)
+
+        # Act
+        emitter = bootstrap.setup_event_emitter(
+            container,
+            domain_events_mapper=domain_events_mapper,
+        )
+
+        # Assert
+        assert len(event_map_received) == 1
+        assert event_map_received[0] is emitter._event_map
+
+    def test_setup_event_emitter_with_cqrs_container_returns_event_emitter(
+        self,
+    ) -> None:
+        # Arrange
+        container = MockCQRSContainer()
+
+        # Act
+        emitter = bootstrap.setup_event_emitter(container)
+
+        # Assert
+        assert isinstance(emitter, events.EventEmitter)
+        assert emitter._container is container
+
+
+# ---------------------------------------------------------------------------
+# Test setup_mediator
+# ---------------------------------------------------------------------------
+
+
+class TestSetupMediator:
+    """AAA tests for bootstrap.setup_mediator."""
+
+    def test_setup_mediator_returns_request_mediator(self) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = bootstrap.setup_event_emitter(container)
+        middlewares: list[mediator_middlewares.Middleware] = [
+            logging_middleware.LoggingMiddleware(),
+        ]
+
+        # Act
+        mediator = bootstrap.setup_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+        )
+
+        # Assert
+        assert isinstance(mediator, cqrs.RequestMediator)
+        assert mediator._event_processor._event_emitter is emitter
+        assert mediator._dispatcher._container is container
+
+    def test_setup_mediator_with_commands_mapper_registers_commands(self) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+        request_map_received: list[RequestMap] = []
+
+        def commands_mapper(m: RequestMap) -> None:
+            request_map_received.append(m)
+
+        # Act
+        mediator = bootstrap.setup_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+            commands_mapper=commands_mapper,
+        )
+
+        # Assert
+        assert len(request_map_received) == 1
+        assert request_map_received[0] is mediator._dispatcher._request_map
+
+    def test_setup_mediator_with_queries_mapper_registers_queries(self) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+        request_map_received: list[RequestMap] = []
+
+        def queries_mapper(m: RequestMap) -> None:
+            request_map_received.append(m)
+
+        # Act
+        bootstrap.setup_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+            queries_mapper=queries_mapper,
+        )
+
+        # Assert
+        assert len(request_map_received) == 1
+
+    def test_setup_mediator_with_custom_event_map_uses_provided_map(self) -> None:
+        # Arrange: non-empty EventMap (empty dict is falsy, so mediator would use new map)
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+        custom_event_map = events.EventMap()
+        custom_event_map.bind(_StubEvent, _StubEventHandler)
+
+        # Act
+        mediator = bootstrap.setup_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+            event_map=custom_event_map,
+        )
+
+        # Assert
+        assert mediator._event_processor._event_map is custom_event_map
+
+    def test_setup_mediator_with_max_concurrent_and_concurrent_enable(self) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+
+        # Act
+        mediator = bootstrap.setup_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+            max_concurrent_event_handlers=5,
+            concurrent_event_handle_enable=True,
+        )
+
+        # Assert
+        assert mediator._event_processor._max_concurrent_event_handlers == 5
+        assert mediator._event_processor._concurrent_event_handle_enable is True
+
+
+# ---------------------------------------------------------------------------
+# Test bootstrap (requests)
+# ---------------------------------------------------------------------------
+
+
+class TestBootstrapRequests:
+    """AAA tests for bootstrap.bootstrap (request mediator)."""
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_di_container_returns_request_mediator(
+        self,
+    ) -> None:
+        # Arrange
+        di_container = di.Container()
+
+        # Act
+        mediator = bootstrap.bootstrap(di_container=di_container)
+
+        # Assert
+        assert isinstance(mediator, cqrs.RequestMediator)
+        assert mediator._event_processor is not None
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_cqrs_container_returns_request_mediator(
+        self,
+    ) -> None:
+        # Arrange
+        container = MockCQRSContainer()
+
+        # Act
+        mediator = bootstrap.bootstrap(di_container=container)
+
+        # Assert
+        assert isinstance(mediator, cqrs.RequestMediator)
+        assert mediator._dispatcher._container is container
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_calls_on_startup_callables(self) -> None:
+        # Arrange
+        di_container = di.Container()
+        on_startup_called: list[int] = []
+
+        def on_startup_1() -> None:
+            on_startup_called.append(1)
+
+        def on_startup_2() -> None:
+            on_startup_called.append(2)
+
+        # Act
+        bootstrap.bootstrap(
+            di_container=di_container,
+            on_startup=[on_startup_1, on_startup_2],
+        )
+
+        # Assert
+        assert on_startup_called == [1, 2]
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_on_startup_none_does_not_fail(self) -> None:
+        # Arrange
+        di_container = di.Container()
+
+        # Act & Assert (no exception)
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            on_startup=None,
+        )
+        assert isinstance(mediator, cqrs.RequestMediator)
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_appends_logging_middleware_if_not_present(
+        self,
+    ) -> None:
+        # Arrange
+        di_container = di.Container()
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            middlewares=[],
+        )
+
+        # Assert: mediator has dispatcher with middleware chain
+        assert mediator._dispatcher._middleware_chain is not None
+        assert isinstance(mediator, cqrs.RequestMediator)
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_existing_logging_middleware_does_not_duplicate(
+        self,
+    ) -> None:
+        # Arrange
+        di_container = di.Container()
+        middlewares = [logging_middleware.LoggingMiddleware()]
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            middlewares=middlewares,
+        )
+
+        # Assert
+        assert isinstance(mediator, cqrs.RequestMediator)
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_custom_message_broker(self) -> None:
+        # Arrange
+        di_container = di.Container()
+        broker = devnull.DevnullMessageBroker()
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            message_broker=broker,
+        )
+
+        # Assert
+        assert mediator._event_processor._event_emitter is not None
+        assert mediator._event_processor._event_emitter._message_broker is broker
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_commands_and_queries_mapper(self) -> None:
+        # Arrange
+        di_container = di.Container()
+        commands_called = False
+        queries_called = False
+
+        def commands_mapper(m: RequestMap) -> None:
+            nonlocal commands_called
+            commands_called = True
+
+        def queries_mapper(m: RequestMap) -> None:
+            nonlocal queries_called
+            queries_called = True
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            commands_mapper=commands_mapper,
+            queries_mapper=queries_mapper,
+        )
+
+        # Assert
+        assert commands_called
+        assert queries_called
+        assert isinstance(mediator, cqrs.RequestMediator)
+
+
+# ---------------------------------------------------------------------------
+# Test setup_streaming_mediator
+# ---------------------------------------------------------------------------
+
+
+class TestSetupStreamingMediator:
+    """AAA tests for bootstrap.setup_streaming_mediator."""
+
+    def test_setup_streaming_mediator_returns_streaming_request_mediator(
+        self,
+    ) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+
+        # Act
+        mediator = bootstrap.setup_streaming_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+        )
+
+        # Assert
+        assert isinstance(mediator, cqrs.StreamingRequestMediator)
+        assert mediator._event_processor._event_emitter is emitter
+
+    def test_setup_streaming_mediator_with_commands_and_queries_mapper(
+        self,
+    ) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+        requests_map_received: list[RequestMap] = []
+
+        def commands_mapper(m: RequestMap) -> None:
+            requests_map_received.append(m)
+
+        def queries_mapper(m: RequestMap) -> None:
+            requests_map_received.append(m)
+
+        # Act
+        mediator = bootstrap.setup_streaming_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+            commands_mapper=commands_mapper,
+            queries_mapper=queries_mapper,
+        )
+
+        # Assert
+        assert len(requests_map_received) == 2
+        assert mediator._dispatcher._request_map is requests_map_received[0]
+
+    def test_setup_streaming_mediator_with_domain_events_mapper(self) -> None:
+        # Arrange: bind in mapper so EventMap is non-empty (empty dict is falsy in mediator)
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+        event_map_received: list[events.EventMap] = []
+
+        def domain_events_mapper(m: events.EventMap) -> None:
+            event_map_received.append(m)
+            m.bind(_StubEvent, _StubEventHandler)
+
+        # Act
+        mediator = bootstrap.setup_streaming_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+            domain_events_mapper=domain_events_mapper,
+        )
+
+        # Assert
+        assert len(event_map_received) == 1
+        assert mediator._event_processor._event_map is event_map_received[0]
+
+    def test_setup_streaming_mediator_with_max_concurrent_params(self) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+
+        # Act
+        mediator = bootstrap.setup_streaming_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+            max_concurrent_event_handlers=20,
+            concurrent_event_handle_enable=False,
+        )
+
+        # Assert
+        assert mediator._event_processor._max_concurrent_event_handlers == 20
+        assert mediator._event_processor._concurrent_event_handle_enable is False
+
+
+# ---------------------------------------------------------------------------
+# Test bootstrap_streaming
+# ---------------------------------------------------------------------------
+
+
+class TestBootstrapStreaming:
+    """AAA tests for bootstrap.bootstrap_streaming."""
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_streaming_with_di_container_returns_streaming_mediator(
+        self,
+    ) -> None:
+        # Arrange
+        di_container = di.Container()
+
+        # Act
+        mediator = bootstrap.bootstrap_streaming(di_container=di_container)
+
+        # Assert
+        assert isinstance(mediator, cqrs.StreamingRequestMediator)
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_streaming_with_cqrs_container(self) -> None:
+        # Arrange
+        container = MockCQRSContainer()
+
+        # Act
+        mediator = bootstrap.bootstrap_streaming(di_container=container)
+
+        # Assert
+        assert isinstance(mediator, cqrs.StreamingRequestMediator)
+        assert mediator._dispatcher._container is container
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_streaming_calls_on_startup(self) -> None:
+        # Arrange
+        di_container = di.Container()
+        called: list[str] = []
+
+        def on_startup() -> None:
+            called.append("startup")
+
+        # Act
+        bootstrap.bootstrap_streaming(
+            di_container=di_container,
+            on_startup=[on_startup],
+        )
+
+        # Assert
+        assert called == ["startup"]
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_streaming_with_on_startup_none(self) -> None:
+        # Arrange
+        di_container = di.Container()
+
+        # Act & Assert
+        mediator = bootstrap.bootstrap_streaming(
+            di_container=di_container,
+            on_startup=None,
+        )
+        assert isinstance(mediator, cqrs.StreamingRequestMediator)
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_streaming_with_custom_message_broker(self) -> None:
+        # Arrange
+        di_container = di.Container()
+        broker = devnull.DevnullMessageBroker()
+
+        # Act
+        mediator = bootstrap.bootstrap_streaming(
+            di_container=di_container,
+            message_broker=broker,
+        )
+
+        # Assert
+        assert mediator._event_processor._event_emitter is not None
+        assert mediator._event_processor._event_emitter._message_broker is broker
diff --git a/tests/unit/test_saga/test_fallback.py b/tests/unit/test_saga/test_fallback.py
new file mode 100644
index 0000000..81c1075
--- /dev/null
+++ b/tests/unit/test_saga/test_fallback.py
@@ -0,0 +1,718 @@
+"""Tests for Fallback mechanism in Saga."""
+
+import typing
+
+import pytest
+
+from cqrs.adapters.circuit_breaker import AioBreakerAdapter
+from cqrs.events.event import Event
+from cqrs.saga.fallback import Fallback
+from cqrs.saga.saga import Saga
+from cqrs.saga.step import SagaStepHandler, SagaStepResult
+from cqrs.saga.storage.enums import SagaStatus, SagaStepStatus
+from cqrs.saga.storage.memory import MemorySagaStorage
+from .conftest import (
+    OrderContext,
+    ProcessPaymentResponse,
+    ProcessPaymentStep,
+    ReserveInventoryResponse,
+    SagaContainer,
+)
+
+
+# Test step handlers for Fallback
+class FailingStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+    """Step that always fails."""
+
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+        self.act_called = False
+        self.compensate_called = False
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        self.act_called = True
+        # Modify context to test snapshot/restore
+        context.amount = 999.0
+        raise RuntimeError("Primary step failed")
+
+    async def compensate(self, context: OrderContext) -> None:
+        self.compensate_called = True
+
+
+class FallbackStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+    """Fallback step that succeeds."""
+
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+        self.act_called = False
+        self.compensate_called = False
+        self._inventory_id: str | None = None
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        self.act_called = True
+        # Verify context was restored (amount should be original, not 999.0)
+        assert context.amount != 999.0, "Context should be restored from snapshot"
+        self._inventory_id = f"fallback_inv_{context.order_id}"
+        response = ReserveInventoryResponse(
+            inventory_id=self._inventory_id,
+            reserved=True,
+        )
+        # Modify context to verify changes persist
+        context.amount = 888.0
+        return self._generate_step_result(response)
+
+    async def compensate(self, context: OrderContext) -> None:
+        self.compensate_called = True
+        self._inventory_id = None
+
+
+class FailingFallbackStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+    """Fallback step that also fails."""
+
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+        self.act_called = False
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        self.act_called = True
+        raise RuntimeError("Fallback step also failed")
+
+    async def compensate(self, context: OrderContext) -> None:
+        pass
+
+
+class BusinessException(Exception):
+    """Business exception that should not open circuit breaker."""
+
+    pass
+
+
+class StepWithBusinessException(
+    SagaStepHandler[OrderContext, ReserveInventoryResponse],
+):
+    """Step that raises business exception."""
+
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+        self.act_called = False
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        self.act_called = True
+        raise BusinessException("Business logic error")
+
+    async def compensate(self, context: OrderContext) -> None:
+        pass
+
+
+class StepWithSpecificException(
+    SagaStepHandler[OrderContext, ReserveInventoryResponse],
+):
+    """Step that raises a specific exception type."""
+
+    def __init__(self) -> None:
+        self._events: list[Event] = []
+        self.act_called = False
+
+    @property
+    def events(self) -> list[Event]:
+        return self._events.copy()
+
+    async def act(
+        self,
+        context: OrderContext,
+    ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+        self.act_called = True
+        raise ConnectionError("Connection failed")
+
+    async def compensate(self, context: OrderContext) -> None:
+        pass
+
+
+@pytest.fixture
+def container():
+    """Create a simple DI container."""
+    return SagaContainer()
+
+
+@pytest.fixture
+def storage():
+    """Create memory storage."""
+    return MemorySagaStorage()
+
+
+@pytest.mark.asyncio
+async def test_fallback_execution_on_primary_failure(container, storage):
+    """Test that fallback is executed when primary step fails."""
+
+    # Create saga with Fallback
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=FailingStep,
+                fallback=FallbackStep,
+            ),
+            ProcessPaymentStep,
+        ]
+
+    saga = TestSaga()
+    context = OrderContext(order_id="123", user_id="user1", amount=100.0)
+    results: list[SagaStepResult[OrderContext, typing.Any]] = []
+
+    async with saga.transaction(
+        context=context,
+        container=container,
+        storage=storage,
+    ) as transaction:
+        async for result in transaction:
+            results.append(result)
+
+    # Verify fallback was executed
+    assert len(results) == 2  # Fallback step + ProcessPaymentStep
+    assert results[0].response.inventory_id == "fallback_inv_123"
+
+    # Verify context was restored before fallback execution
+    # (amount should be original, not modified by failing step)
+    # But then modified by fallback step
+    assert context.amount == 888.0
+
+    # Verify step history
+    history = await storage.get_step_history(transaction.saga_id)
+    step_names = {e.step_name for e in history if e.status == SagaStepStatus.COMPLETED}
+    assert "FallbackStep" in step_names
+    assert "FailingStep" not in step_names  # Should not be logged as completed
+
+    # Verify saga completed successfully
+    status, _, _ = await storage.load_saga_state(transaction.saga_id)
+    assert status == SagaStatus.COMPLETED
+
+
+@pytest.mark.asyncio
+async def test_fallback_with_failure_exceptions(container, storage):
+    """Test that fallback is triggered for specific exception types."""
+
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=StepWithSpecificException,
+                fallback=FallbackStep,
+                failure_exceptions=(ConnectionError,),
+            ),
+        ]
+
+    saga = TestSaga()
+    context = OrderContext(order_id="123", user_id="user1", amount=100.0)
+    results: list[SagaStepResult[OrderContext, typing.Any]] = []
+
+    async with saga.transaction(
+        context=context,
+        container=container,
+        storage=storage,
+    ) as transaction:
+        async for result in transaction:
+            results.append(result)
+
+    # Verify fallback was executed
+    assert len(results) == 1
+    assert results[0].response.inventory_id == "fallback_inv_123"
+
+    # Verify step history
+    history = await storage.get_step_history(transaction.saga_id)
+    step_names = {e.step_name for e in history if e.status == SagaStepStatus.COMPLETED}
+    assert "FallbackStep" in step_names
+
+
+@pytest.mark.asyncio
+async def test_fallback_failure_triggers_saga_failure(container, storage):
+    """Test that if fallback also fails, saga fails."""
+    import uuid
+
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=FailingStep,
+                fallback=FailingFallbackStep,
+            ),
+        ]
+
+    saga = TestSaga()
+    context = OrderContext(order_id="123", user_id="user1", amount=100.0)
+    saga_id = uuid.uuid4()
+
+    with pytest.raises(RuntimeError, match="Fallback step also failed"):
+        async with saga.transaction(
+            context=context,
+            container=container,
+            storage=storage,
+            saga_id=saga_id,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    # Verify saga failed
+    status, _, _ = await storage.load_saga_state(saga_id)
+    assert status == SagaStatus.FAILED
+
+
+@pytest.mark.asyncio
+async def test_fallback_idempotency(container, storage):
+    """Test that completed fallback steps are skipped on recovery."""
+
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=FailingStep,
+                fallback=FallbackStep,
+            ),
+            ProcessPaymentStep,
+        ]
+
+    saga = TestSaga()
+    context = OrderContext(order_id="123", user_id="user1", amount=100.0)
+
+    # First execution - fallback should execute
+    results1: list[SagaStepResult[OrderContext, typing.Any]] = []
+    async with saga.transaction(
+        context=context,
+        container=container,
+        storage=storage,
+    ) as transaction1:
+        async for result in transaction1:
+            results1.append(result)
+
+    saga_id = transaction1.saga_id
+
+    # Second execution with same saga_id - should skip completed steps
+    context2 = OrderContext(order_id="123", user_id="user1", amount=100.0)
+    results2: list[SagaStepResult[OrderContext, typing.Any]] = []
+    async with saga.transaction(
+        context=context2,
+        container=container,
+        storage=storage,
+        saga_id=saga_id,
+    ) as transaction2:
+        async for result in transaction2:
+            results2.append(result)
+
+    # Should have no new results (all steps already completed)
+    assert len(results2) == 0
+
+
+@pytest.mark.asyncio
+async def test_fallback_with_circuit_breaker(container, storage):
+    """Test Fallback with circuit breaker integration."""
+    pytest.importorskip("aiobreaker")
+
+    # Create circuit breaker adapter with unique namespace for this test
+    cb_adapter = AioBreakerAdapter(
+        fail_max=3,  # Increase to 3 to allow 2 failures before opening
+        timeout_duration=1,
+        exclude=[BusinessException],
+    )
+
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=FailingStep,
+                fallback=FallbackStep,
+                circuit_breaker=cb_adapter,
+            ),
+        ]
+
+    saga = TestSaga()
+    context = OrderContext(order_id="123", user_id="user1", amount=100.0)
+
+    # First failure - should trigger fallback
+    results1: list[SagaStepResult[OrderContext, typing.Any]] = []
+    async with saga.transaction(
+        context=context,
+        container=container,
+        storage=storage,
+    ) as transaction1:
+        async for result in transaction1:
+            results1.append(result)
+
+    assert len(results1) == 1
+    assert results1[0].response.inventory_id == "fallback_inv_123"
+
+    # Second failure - should trigger fallback again
+    context2 = OrderContext(order_id="456", user_id="user2", amount=200.0)
+    results2: list[SagaStepResult[OrderContext, typing.Any]] = []
+    async with saga.transaction(
+        context=context2,
+        container=container,
+        storage=storage,
+    ) as transaction2:
+        async for result in transaction2:
+            results2.append(result)
+
+    assert len(results2) == 1
+    assert results2[0].response.inventory_id == "fallback_inv_456"
+
+
+@pytest.mark.asyncio
+async def test_circuit_breaker_namespace_isolation(container, storage):
+    """Test that different steps have isolated circuit breaker states."""
+    pytest.importorskip("aiobreaker")
+
+    # Create adapter with higher fail_max to allow multiple failures
+    cb_adapter = AioBreakerAdapter(
+        fail_max=3,
+        timeout_duration=1,
+    )
+
+    class AnotherFailingStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+        """Another failing step for namespace isolation test."""
+
+        def __init__(self) -> None:
+            self._events: list[Event] = []
+            self.act_called = False
+
+        @property
+        def events(self) -> list[Event]:
+            return self._events.copy()
+
+        async def act(
+            self,
+            context: OrderContext,
+        ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+            self.act_called = True
+            raise RuntimeError("Another step failed")
+
+        async def compensate(self, context: OrderContext) -> None:
+            pass
+
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=FailingStep,
+                fallback=FallbackStep,
+                circuit_breaker=cb_adapter,
+            ),
+            Fallback(
+                step=AnotherFailingStep,
+                fallback=FallbackStep,
+                circuit_breaker=cb_adapter,
+            ),
+        ]
+
+    saga = TestSaga()
+    context = OrderContext(order_id="123", user_id="user1", amount=100.0)
+
+    results: list[SagaStepResult[OrderContext, typing.Any]] = []
+    async with saga.transaction(
+        context=context,
+        container=container,
+        storage=storage,
+    ) as transaction:
+        async for result in transaction:
+            results.append(result)
+
+    # Both steps should have triggered fallbacks
+    # Namespace isolation ensures one step's failures don't affect the other
+    assert len(results) == 2
+    assert results[0].response.inventory_id == "fallback_inv_123"
+    assert results[1].response.inventory_id == "fallback_inv_123"
+
+
+@pytest.mark.asyncio
+async def test_business_exception_does_not_open_circuit(container, storage):
+    """Test that business exceptions don't open the circuit breaker."""
+    pytest.importorskip("aiobreaker")
+
+    cb_adapter = AioBreakerAdapter(
+        fail_max=1,
+        timeout_duration=1,
+        exclude=[BusinessException],
+    )
+
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=StepWithBusinessException,
+                fallback=FallbackStep,
+                circuit_breaker=cb_adapter,
+            ),
+        ]
+
+    saga = TestSaga()
+
+    # Execute multiple times - business exception should not open circuit
+    for i in range(3):
+        context_i = OrderContext(order_id=f"123_{i}", user_id="user1", amount=100.0)
+        results: list[SagaStepResult[OrderContext, typing.Any]] = []
+        async with saga.transaction(
+            context=context_i,
+            container=container,
+            storage=storage,
+        ) as transaction:
+            async for result in transaction:
+                results.append(result)
+
+        # Fallback should execute each time (circuit should not be open)
+        assert len(results) == 1
+        assert results[0].response.inventory_id == f"fallback_inv_123_{i}"
+
+
+@pytest.mark.asyncio
+async def test_primary_step_success_no_fallback(container, storage):
+    """Test that fallback is not executed when primary step succeeds."""
+
+    class SuccessfulStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+        """Step that succeeds."""
+
+        def __init__(self) -> None:
+            self._events: list[Event] = []
+            self.act_called = False
+            self._inventory_id: str | None = None
+
+        @property
+        def events(self) -> list[Event]:
+            return self._events.copy()
+
+        async def act(
+            self,
+            context: OrderContext,
+        ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+            self.act_called = True
+            self._inventory_id = f"primary_inv_{context.order_id}"
+            response = ReserveInventoryResponse(
+                inventory_id=self._inventory_id,
+                reserved=True,
+            )
+            return self._generate_step_result(response)
+
+        async def compensate(self, context: OrderContext) -> None:
+            pass
+
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=SuccessfulStep,
+                fallback=FallbackStep,
+            ),
+        ]
+
+    saga = TestSaga()
+    context = OrderContext(order_id="123", user_id="user1", amount=100.0)
+
+    results: list[SagaStepResult[OrderContext, typing.Any]] = []
+    async with saga.transaction(
+        context=context,
+        container=container,
+        storage=storage,
+    ) as transaction:
+        async for result in transaction:
+            results.append(result)
+
+    # Primary step should succeed, fallback should not execute
+    assert len(results) == 1
+    assert results[0].response.inventory_id == "primary_inv_123"
+
+    # Verify fallback step was not called
+    fallback_step = await container.resolve(FallbackStep)
+    assert not fallback_step.act_called
+
+    # Verify step history
+    history = await storage.get_step_history(transaction.saga_id)
+    step_names = {e.step_name for e in history if e.status == SagaStepStatus.COMPLETED}
+    assert "SuccessfulStep" in step_names
+    assert "FallbackStep" not in step_names
+
+
+@pytest.mark.asyncio
+async def test_fallback_context_snapshot_restore(container, storage):
+    """Test that context is properly snapshot and restored on fallback."""
+
+    class ContextModifyingFailingStep(
+        SagaStepHandler[OrderContext, ReserveInventoryResponse],
+    ):
+        """Step that modifies context then fails."""
+
+        def __init__(self) -> None:
+            self._events: list[Event] = []
+            self.act_called = False
+
+        @property
+        def events(self) -> list[Event]:
+            return self._events.copy()
+
+        async def act(
+            self,
+            context: OrderContext,
+        ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+            self.act_called = True
+            # Modify context
+            context.amount = 999.0
+            context.order_id = "modified"
+            raise RuntimeError("Failed after modifying context")
+
+        async def compensate(self, context: OrderContext) -> None:
+            pass
+
+    class ContextVerifyingFallbackStep(
+        SagaStepHandler[OrderContext, ReserveInventoryResponse],
+    ):
+        """Fallback step that verifies context was restored."""
+
+        def __init__(self) -> None:
+            self._events: list[Event] = []
+            self.act_called = False
+            self._inventory_id: str | None = None
+
+        @property
+        def events(self) -> list[Event]:
+            return self._events.copy()
+
+        async def act(
+            self,
+            context: OrderContext,
+        ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+            self.act_called = True
+            # Verify context was restored (not modified by failing step)
+            assert context.amount == 100.0, "Context amount should be restored"
+            assert context.order_id == "123", "Context order_id should be restored"
+            self._inventory_id = f"fallback_inv_{context.order_id}"
+            response = ReserveInventoryResponse(
+                inventory_id=self._inventory_id,
+                reserved=True,
+            )
+            return self._generate_step_result(response)
+
+        async def compensate(self, context: OrderContext) -> None:
+            pass
+
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=ContextModifyingFailingStep,
+                fallback=ContextVerifyingFallbackStep,
+            ),
+        ]
+
+    saga = TestSaga()
+    context = OrderContext(order_id="123", user_id="user1", amount=100.0)
+
+    results: list[SagaStepResult[OrderContext, typing.Any]] = []
+    async with saga.transaction(
+        context=context,
+        container=container,
+        storage=storage,
+    ) as transaction:
+        async for result in transaction:
+            results.append(result)
+
+    # Verify fallback executed and context was restored
+    assert len(results) == 1
+    assert results[0].response.inventory_id == "fallback_inv_123"
+
+
+@pytest.mark.asyncio
+async def test_fallback_compensation(container, storage):
+    """Test that fallback steps are properly compensated when saga fails."""
+
+    class CompensatableFallbackStep(
+        SagaStepHandler[OrderContext, ReserveInventoryResponse],
+    ):
+        """Fallback step that can be compensated."""
+
+        def __init__(self) -> None:
+            self._events: list[Event] = []
+            self.act_called = False
+            self.compensate_called = False
+            self._inventory_id: str | None = None
+
+        @property
+        def events(self) -> list[Event]:
+            return self._events.copy()
+
+        async def act(
+            self,
+            context: OrderContext,
+        ) -> SagaStepResult[OrderContext, ReserveInventoryResponse]:
+            self.act_called = True
+            self._inventory_id = f"fallback_inv_{context.order_id}"
+            response = ReserveInventoryResponse(
+                inventory_id=self._inventory_id,
+                reserved=True,
+            )
+            return self._generate_step_result(response)
+
+        async def compensate(self, context: OrderContext) -> None:
+            self.compensate_called = True
+            self._inventory_id = None
+
+    class FailingNextStep(SagaStepHandler[OrderContext, ProcessPaymentResponse]):
+        """Step that fails after fallback succeeds."""
+
+        def __init__(self) -> None:
+            self._events: list[Event] = []
+            self.act_called = False
+
+        @property
+        def events(self) -> list[Event]:
+            return self._events.copy()
+
+        async def act(
+            self,
+            context: OrderContext,
+        ) -> SagaStepResult[OrderContext, ProcessPaymentResponse]:
+            self.act_called = True
+            raise RuntimeError("Next step failed")
+
+        async def compensate(self, context: OrderContext) -> None:
+            pass
+
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=FailingStep,
+                fallback=CompensatableFallbackStep,
+            ),
+            FailingNextStep,
+        ]
+
+    saga = TestSaga()
+    context = OrderContext(order_id="123", user_id="user1", amount=100.0)
+
+    with pytest.raises(RuntimeError, match="Next step failed"):
+        async with saga.transaction(
+            context=context,
+            container=container,
+            storage=storage,
+        ) as transaction:
+            async for _ in transaction:
+                pass
+
+    # Verify fallback step was compensated
+    fallback_step = await container.resolve(CompensatableFallbackStep)
+    assert fallback_step.act_called
+    assert fallback_step.compensate_called
+    assert fallback_step._inventory_id is None
diff --git a/tests/unit/test_saga/test_saga_basic.py b/tests/unit/test_saga/test_saga_basic.py
index 38d4515..d06df57 100644
--- a/tests/unit/test_saga/test_saga_basic.py
+++ b/tests/unit/test_saga/test_saga_basic.py
@@ -313,3 +313,4 @@ async def test_saga_step_result_contains_correct_metadata(
         assert step_result.error_message is None
         assert step_result.error_traceback is None
         assert step_result.error_type is None
+        assert step_result.saga_id is not None
diff --git a/tests/unit/test_saga/test_saga_compensation_retry.py b/tests/unit/test_saga/test_saga_compensation_retry.py
index 776edaf..0fd3163 100644
--- a/tests/unit/test_saga/test_saga_compensation_retry.py
+++ b/tests/unit/test_saga/test_saga_compensation_retry.py
@@ -111,8 +111,8 @@ async def mock_sleep(delay: float) -> None:
         sleep_times.append(delay)
         # Return immediately without actual sleep
 
-    # Patch asyncio.sleep in the saga module where it's used
-    with patch("cqrs.saga.saga.asyncio.sleep", side_effect=mock_sleep):
+    # Patch asyncio.sleep in the compensation module where it's used
+    with patch("cqrs.saga.compensation.asyncio.sleep", side_effect=mock_sleep):
         with pytest.raises(ValueError):
             async with saga.transaction(
                 context=context,
@@ -135,9 +135,7 @@ async def mock_sleep(delay: float) -> None:
     # Attempt 4 succeeds -> no wait
     expected_delays = [initial_delay * (backoff_multiplier**i) for i in range(3)]
 
-    assert (
-        len(sleep_times) == 3
-    ), f"Expected 3 sleep calls, got {len(sleep_times)}: {sleep_times}"
+    assert len(sleep_times) == 3, f"Expected 3 sleep calls, got {len(sleep_times)}: {sleep_times}"
     for actual, expected in zip(sleep_times, expected_delays):
         assert abs(actual - expected) < 0.01, f"Expected {expected}, got {actual}"
 
diff --git a/tests/unit/test_saga/test_saga_recovery.py b/tests/unit/test_saga/test_saga_recovery.py
index b33b48a..07f889c 100644
--- a/tests/unit/test_saga/test_saga_recovery.py
+++ b/tests/unit/test_saga/test_saga_recovery.py
@@ -272,8 +272,10 @@ class TestSaga(Saga[OrderContext]):
 
     saga = TestSaga()
 
-    # Should raise TypeError when required fields are missing
-    with pytest.raises(TypeError):
+    # Should raise MissingFields when required fields are missing
+    from dataclass_wizard.errors import MissingFields
+
+    with pytest.raises(MissingFields):
         await recover_saga(saga, saga_id, OrderContext, saga_container, storage)
 
     assert not reserve_step.act_called
@@ -485,7 +487,7 @@ class TestSaga(Saga[OrderContext]):
     # Verify context was updated in storage
     status, updated_context, _ = await storage.load_saga_state(saga_id)
     assert status == SagaStatus.COMPLETED
-    assert updated_context["order_id"] == "123"
+    assert updated_context["orderId"] == "123"
 
 
 async def test_recover_saga_with_mock_storage_exception(
diff --git a/tests/unit/test_saga/test_saga_storage_run.py b/tests/unit/test_saga/test_saga_storage_run.py
new file mode 100644
index 0000000..d25ebda
--- /dev/null
+++ b/tests/unit/test_saga/test_saga_storage_run.py
@@ -0,0 +1,292 @@
+"""Tests for saga storage create_run() and checkpoint (run) path."""
+
+import typing
+import uuid
+
+import pytest
+
+from cqrs.saga.storage.enums import SagaStatus, SagaStepStatus
+from cqrs.saga.storage.memory import MemorySagaStorage
+from cqrs.saga.storage.protocol import ISagaStorage
+
+from .conftest import (
+    FailingStep,
+    OrderContext,
+    ReserveInventoryStep,
+    SagaContainer,
+    ShipOrderStep,
+)
+
+
+class StorageWithoutCreateRun(ISagaStorage):
+    """Storage that does not implement create_run (legacy path)."""
+
+    def __init__(self) -> None:
+        """
+        Create a storage wrapper that delegates all saga operations to an internal in-memory storage while intentionally not providing `create_run`.
+        """
+        self._inner = MemorySagaStorage()
+
+    async def create_saga(self, saga_id: uuid.UUID, name: str, context: dict) -> None:
+        """
+        Create a new saga record with the given identifier, name, and initial context.
+
+        Parameters:
+            saga_id (uuid.UUID): Unique identifier for the saga.
+            name (str): Human-readable name of the saga.
+            context (dict): Initial context payload for the saga.
+        """
+        await self._inner.create_saga(saga_id, name, context)
+
+    async def update_context(
+        self,
+        saga_id: uuid.UUID,
+        context: dict,
+        current_version: int | None = None,
+    ) -> None:
+        """
+        Update the stored context for a saga, optionally validating the expected current version.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga whose context will be updated.
+            context (dict): New context data to persist for the saga.
+            current_version (int | None): If provided, the update will only proceed when the stored version equals this value; pass None to skip version validation.
+        """
+        await self._inner.update_context(saga_id, context, current_version)
+
+    async def update_status(self, saga_id: uuid.UUID, status: SagaStatus) -> None:
+        """
+        Update the stored status of a saga.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga to update.
+            status (SagaStatus): New status to set for the saga.
+        """
+        await self._inner.update_status(saga_id, status)
+
+    async def log_step(
+        self,
+        saga_id: uuid.UUID,
+        step_name: str,
+        action: typing.Literal["act", "compensate"],
+        status: SagaStepStatus,
+        details: str | None = None,
+    ) -> None:
+        """
+        Record the execution or compensation outcome of a saga step.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga.
+            step_name (str): Name of the step being logged.
+            action (Literal["act", "compensate"]): Whether this log entry is for the step's normal action ("act") or its compensation ("compensate").
+            status (SagaStepStatus): Resulting status of the step.
+            details (str | None): Optional human-readable details or metadata about the step event.
+        """
+        await self._inner.log_step(saga_id, step_name, action, status, details)
+
+    async def load_saga_state(
+        self,
+        saga_id: uuid.UUID,
+        *,
+        read_for_update: bool = False,
+    ) -> tuple[SagaStatus, dict, int]:
+        """
+        Load the current state for a saga from the underlying storage.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga to load.
+            read_for_update (bool): If True, load the state with intent to update (may acquire locks or use a read-for-update strategy).
+
+        Returns:
+            tuple[SagaStatus, dict, int]: A tuple containing the saga's status, its context dictionary, and the current version number.
+        """
+        return await self._inner.load_saga_state(
+            saga_id,
+            read_for_update=read_for_update,
+        )
+
+    async def get_step_history(self, saga_id: uuid.UUID) -> list:
+        """
+        Return the step execution history for the given saga.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga whose history to retrieve.
+
+        Returns:
+            list: Step history records in chronological order. Each record describes the step name, action ("act" or "compensate"), step status, timestamp, and any optional details.
+        """
+        return await self._inner.get_step_history(saga_id)
+
+    async def get_sagas_for_recovery(
+        self,
+        limit: int,
+        max_recovery_attempts: int = 5,
+        stale_after_seconds: int | None = None,
+        saga_name: str | None = None,
+    ) -> list[uuid.UUID]:
+        """
+        Selects saga IDs that are eligible for recovery.
+
+        Parameters:
+            limit (int): Maximum number of saga IDs to return.
+            max_recovery_attempts (int): Only include sagas with fewer than this many recovery attempts.
+            stale_after_seconds (int | None): If provided, only include sagas last updated more than this many seconds ago; if None, do not filter by staleness.
+            saga_name (str | None): If provided, restrict results to sagas with this name.
+
+        Returns:
+            list[uuid.UUID]: Saga UUIDs that match the recovery criteria, up to `limit`.
+        """
+        return await self._inner.get_sagas_for_recovery(
+            limit,
+            max_recovery_attempts=max_recovery_attempts,
+            stale_after_seconds=stale_after_seconds,
+            saga_name=saga_name,
+        )
+
+    async def increment_recovery_attempts(
+        self,
+        saga_id: uuid.UUID,
+        new_status: SagaStatus | None = None,
+    ) -> None:
+        """
+        Increment the recovery-attempts counter for a saga and optionally update its status.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga whose recovery attempts should be incremented.
+            new_status (SagaStatus | None): If provided, update the saga's status to this value after incrementing attempts; otherwise leave status unchanged.
+        """
+        await self._inner.increment_recovery_attempts(saga_id, new_status)
+
+    async def set_recovery_attempts(self, saga_id: uuid.UUID, attempts: int) -> None:
+        """
+        Set the number of recovery attempts recorded for a saga.
+
+        Parameters:
+            saga_id (uuid.UUID): Identifier of the saga whose recovery attempts will be set.
+            attempts (int): Number of recovery attempts to record; should be zero or a positive integer.
+        """
+        await self._inner.set_recovery_attempts(saga_id, attempts)
+
+
+async def test_memory_storage_create_run_yields_run_with_required_methods() -> None:
+    """create_run() yields an object with create_saga, update_*, log_step, commit, rollback."""
+    storage = MemorySagaStorage()
+    async with storage.create_run() as run:
+        assert run is not None
+        assert hasattr(run, "create_saga")
+        assert hasattr(run, "update_context")
+        assert hasattr(run, "update_status")
+        assert hasattr(run, "log_step")
+        assert hasattr(run, "load_saga_state")
+        assert hasattr(run, "get_step_history")
+        assert hasattr(run, "commit")
+        assert hasattr(run, "rollback")
+
+
+async def test_memory_storage_run_commit_rollback_are_no_op() -> None:
+    """Run from MemorySagaStorage: commit and rollback do not raise."""
+    storage = MemorySagaStorage()
+    async with storage.create_run() as run:
+        await run.commit()
+        await run.rollback()
+
+
+async def test_memory_storage_run_persists_after_commit() -> None:
+    """Using run: create_saga + commit makes state visible to storage."""
+    storage = MemorySagaStorage()
+    saga_id = uuid.uuid4()
+    async with storage.create_run() as run:
+        await run.create_saga(saga_id, "TestSaga", {"key": "value"})
+        await run.update_status(saga_id, SagaStatus.RUNNING)
+        await run.commit()
+    status, context, version = await storage.load_saga_state(saga_id)
+    assert status == SagaStatus.RUNNING
+    assert context == {"key": "value"}
+    assert version >= 1
+
+
+async def test_saga_with_storage_with_create_run_completes_successfully() -> None:
+    """Saga with MemorySagaStorage (has create_run) uses run path and completes."""
+    from cqrs.saga.saga import Saga
+
+    class TwoStepSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep, ShipOrderStep]
+
+    container = SagaContainer()
+    container.register(ReserveInventoryStep, ReserveInventoryStep())
+    container.register(ShipOrderStep, ShipOrderStep())
+    storage = MemorySagaStorage()
+    saga = TwoStepSaga()
+    context = OrderContext(order_id="o1", user_id="u1", amount=50.0)
+    results = []
+    async with saga.transaction(
+        context=context,
+        container=container,  # type: ignore[arg-type]
+        storage=storage,
+    ) as transaction:
+        async for step_result in transaction:
+            results.append(step_result)
+    assert len(results) == 2
+    status, _, _ = await storage.load_saga_state(transaction.saga_id)
+    assert status == SagaStatus.COMPLETED
+
+
+async def test_saga_with_storage_without_create_run_completes_successfully() -> None:
+    """Saga with storage that does not implement create_run uses legacy path."""
+    from cqrs.saga.saga import Saga
+
+    class TwoStepSaga(Saga[OrderContext]):
+        steps = [ReserveInventoryStep, ShipOrderStep]
+
+    container = SagaContainer()
+    container.register(ReserveInventoryStep, ReserveInventoryStep())
+    container.register(ShipOrderStep, ShipOrderStep())
+    storage = StorageWithoutCreateRun()
+    saga = TwoStepSaga()
+    context = OrderContext(order_id="o2", user_id="u2", amount=60.0)
+    results = []
+    async with saga.transaction(
+        context=context,
+        container=container,  # type: ignore[arg-type]
+        storage=storage,
+    ) as transaction:
+        async for step_result in transaction:
+            results.append(step_result)
+    assert len(results) == 2
+    status, _, _ = await storage.load_saga_state(transaction.saga_id)
+    assert status == SagaStatus.COMPLETED
+
+
+async def test_saga_with_run_path_compensates_on_failure() -> None:
+    """When a step fails, compensation runs and saga ends in FAILED (run path)."""
+    from cqrs.saga.saga import Saga
+
+    class SagaWithFailure(Saga[OrderContext]):
+        steps = [ReserveInventoryStep, FailingStep]
+
+    container = SagaContainer()
+    container.register(ReserveInventoryStep, ReserveInventoryStep())
+    container.register(FailingStep, FailingStep())
+    storage = MemorySagaStorage()
+    saga = SagaWithFailure()
+    context = OrderContext(order_id="o3", user_id="u3", amount=70.0)
+    saga_id: uuid.UUID | None = None
+    with pytest.raises(ValueError, match="Step failed"):
+        async with saga.transaction(
+            context=context,
+            container=container,  # type: ignore[arg-type]
+            storage=storage,
+        ) as transaction:
+            saga_id = transaction.saga_id
+            async for _ in transaction:
+                pass
+    assert saga_id is not None
+    status, _, _ = await storage.load_saga_state(saga_id)
+    assert status == SagaStatus.FAILED
+
+
+async def test_storage_create_run_raises_not_implemented_by_default() -> None:
+    """Default create_run() on a minimal storage raises NotImplementedError."""
+    storage = StorageWithoutCreateRun()
+    with pytest.raises(NotImplementedError, match="does not support create_run"):
+        storage.create_run()
diff --git a/tests/unit/test_saga/test_saga_to_mermaid.py b/tests/unit/test_saga/test_saga_to_mermaid.py
index 49493ee..d8f8bab 100644
--- a/tests/unit/test_saga/test_saga_to_mermaid.py
+++ b/tests/unit/test_saga/test_saga_to_mermaid.py
@@ -2,6 +2,8 @@
 
 import typing
 
+from cqrs.events.event import Event
+from cqrs.saga.fallback import Fallback
 from cqrs.saga.mermaid import SagaMermaid
 from cqrs.saga.saga import Saga
 from cqrs.saga.step import SagaStepHandler
@@ -9,6 +11,7 @@
 from .conftest import (
     OrderContext,
     ProcessPaymentStep,
+    ReserveInventoryResponse,
     ReserveInventoryStep,
     ShipOrderStep,
     SagaContainer,
@@ -19,9 +22,7 @@ def test_to_mermaid_empty_steps(saga_container: SagaContainer) -> None:
     """Test that Mermaid handles empty steps list correctly."""
 
     class EmptySaga(Saga[OrderContext]):
-        steps: typing.ClassVar[
-            list[type[SagaStepHandler[OrderContext, typing.Any]]]
-        ] = []
+        steps: typing.ClassVar[list[type[SagaStepHandler] | Fallback]] = []
 
     saga = EmptySaga()
     generator = SagaMermaid(saga)
@@ -229,9 +230,7 @@ class TestSaga(Saga[OrderContext]):
     # Check that the name is truncated (should be max 30 chars + "...")
     assert "participant S1 as" in diagram
     # The full name should not appear, but truncated version should
-    participant_line = [
-        line for line in diagram.split("\n") if "participant S1" in line
-    ][0]
+    participant_line = [line for line in diagram.split("\n") if "participant S1" in line][0]
     # Name should be truncated to 30 chars max
     assert len(participant_line.split("as")[1].strip()) <= 33  # 30 + "..."
 
@@ -240,9 +239,7 @@ def test_class_diagram_empty_steps(saga_container: SagaContainer) -> None:
     """Test that class_diagram() handles empty steps list correctly."""
 
     class EmptySaga(Saga[OrderContext]):
-        steps: typing.ClassVar[
-            list[type[SagaStepHandler[OrderContext, typing.Any]]]
-        ] = []
+        steps: typing.ClassVar[list[type[SagaStepHandler] | Fallback]] = []
 
     saga = EmptySaga()
     generator = SagaMermaid(saga)
@@ -330,23 +327,13 @@ class TestSaga(Saga[OrderContext]):
     diagram = generator.class_diagram()
 
     # Check Saga to Step relationships
-    assert (
-        "Saga --> ReserveInventoryStep" in diagram
-        or "Saga --> ReserveInventoryStep : contains" in diagram
-    )
-    assert (
-        "Saga --> ProcessPaymentStep" in diagram
-        or "Saga --> ProcessPaymentStep : contains" in diagram
-    )
-    assert (
-        "Saga --> ShipOrderStep" in diagram
-        or "Saga --> ShipOrderStep : contains" in diagram
-    )
+    assert "Saga --> ReserveInventoryStep" in diagram or "Saga --> ReserveInventoryStep : contains" in diagram
+    assert "Saga --> ProcessPaymentStep" in diagram or "Saga --> ProcessPaymentStep : contains" in diagram
+    assert "Saga --> ShipOrderStep" in diagram or "Saga --> ShipOrderStep : contains" in diagram
 
     # Check Step to Context relationships
     assert (
-        "ReserveInventoryStep ..> OrderContext" in diagram
-        or "ReserveInventoryStep ..> OrderContext : uses" in diagram
+        "ReserveInventoryStep ..> OrderContext" in diagram or "ReserveInventoryStep ..> OrderContext : uses" in diagram
     )
 
     # Check Step to Response relationships
@@ -359,8 +346,7 @@ class TestSaga(Saga[OrderContext]):
         or "ProcessPaymentStep ..> ProcessPaymentResponse : returns" in diagram
     )
     assert (
-        "ShipOrderStep ..> ShipOrderResponse" in diagram
-        or "ShipOrderStep ..> ShipOrderResponse : returns" in diagram
+        "ShipOrderStep ..> ShipOrderResponse" in diagram or "ShipOrderStep ..> ShipOrderResponse : returns" in diagram
     )
 
 
@@ -380,3 +366,159 @@ class TestSaga(Saga[OrderContext]):
     assert "class ReserveInventoryStep" in diagram
     assert "class OrderContext" in diagram
     assert "class ReserveInventoryResponse" in diagram
+
+
+def test_sequence_diagram_with_fallback(saga_container: SagaContainer) -> None:
+    """Test that sequence diagram correctly shows Fallback steps."""
+
+    class FallbackStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+        def __init__(self) -> None:
+            self._events: list[Event] = []
+
+        @property
+        def events(self) -> list[Event]:
+            return self._events.copy()
+
+        async def act(
+            self,
+            context: OrderContext,
+        ) -> typing.Any:
+            return self._generate_step_result(
+                ReserveInventoryResponse(inventory_id="fallback_123", reserved=True),
+            )
+
+        async def compensate(self, context: OrderContext) -> None:
+            pass
+
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=ReserveInventoryStep,
+                fallback=FallbackStep,
+            ),
+            ProcessPaymentStep,
+        ]
+
+    saga = TestSaga()
+    generator = SagaMermaid(saga)
+
+    diagram = generator.sequence()
+
+    # Check that both primary and fallback participants are present
+    assert "participant S as Saga" in diagram
+    assert "participant S1 as ReserveInventoryStep" in diagram
+    assert "participant F1 as" in diagram  # Fallback step alias
+    assert "fallback" in diagram.lower()  # Should mention fallback
+
+    # Check successful execution flow includes primary step
+    assert "S->>S1: act()" in diagram
+    assert "S1-->>S: success" in diagram
+
+    # Check failure flow shows primary failing and fallback succeeding
+    failure_section_start = diagram.find("Failure & Compensation Flow")
+    if failure_section_start != -1:
+        failure_section = diagram[failure_section_start:]
+        # Should show primary failing, then fallback succeeding
+        assert "S->>S1: act()" in failure_section or "S->>F1: act()" in failure_section
+
+
+def test_class_diagram_with_fallback(saga_container: SagaContainer) -> None:
+    """Test that class diagram correctly shows Fallback steps."""
+
+    class FallbackStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+        def __init__(self) -> None:
+            self._events: list[Event] = []
+
+        @property
+        def events(self) -> list[Event]:
+            return self._events.copy()
+
+        async def act(
+            self,
+            context: OrderContext,
+        ) -> typing.Any:
+            return self._generate_step_result(
+                ReserveInventoryResponse(inventory_id="fallback_123", reserved=True),
+            )
+
+        async def compensate(self, context: OrderContext) -> None:
+            pass
+
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=ReserveInventoryStep,
+                fallback=FallbackStep,
+            ),
+        ]
+
+    saga = TestSaga()
+    generator = SagaMermaid(saga)
+
+    diagram = generator.class_diagram()
+
+    # Check that both primary and fallback step classes are included
+    assert "classDiagram" in diagram
+    assert "class Saga" in diagram
+    assert "class ReserveInventoryStep" in diagram
+    assert "class FallbackStep" in diagram
+    assert "class OrderContext" in diagram
+    assert "class ReserveInventoryResponse" in diagram
+
+    # Check relationships
+    assert "Saga --> ReserveInventoryStep" in diagram or "Saga --> ReserveInventoryStep : contains" in diagram
+    assert "Saga --> FallbackStep" in diagram or "Saga --> FallbackStep : contains" in diagram
+
+
+def test_sequence_diagram_fallback_single_step(saga_container: SagaContainer) -> None:
+    """Test sequence diagram with single Fallback step."""
+
+    class FallbackStep(SagaStepHandler[OrderContext, ReserveInventoryResponse]):
+        def __init__(self) -> None:
+            self._events: list[Event] = []
+
+        @property
+        def events(self) -> list[Event]:
+            return self._events.copy()
+
+        async def act(
+            self,
+            context: OrderContext,
+        ) -> typing.Any:
+            return self._generate_step_result(
+                ReserveInventoryResponse(inventory_id="fallback_123", reserved=True),
+            )
+
+        async def compensate(self, context: OrderContext) -> None:
+            pass
+
+    class TestSaga(Saga[OrderContext]):
+        steps = [
+            Fallback(
+                step=ReserveInventoryStep,
+                fallback=FallbackStep,
+            ),
+        ]
+
+    saga = TestSaga()
+    generator = SagaMermaid(saga)
+
+    diagram = generator.sequence()
+
+    # Check participants
+    assert "participant S as Saga" in diagram
+    assert "participant S1 as ReserveInventoryStep" in diagram
+    assert "participant F1 as" in diagram  # Fallback step
+
+    # Check successful flow shows primary step
+    assert "Successful Execution Flow" in diagram
+    assert "S->>S1: act()" in diagram
+    assert "S1-->>S: success" in diagram
+
+    # Check failure flow shows fallback
+    assert "Failure & Compensation Flow" in diagram
+    failure_section_start = diagram.find("Failure & Compensation Flow")
+    if failure_section_start != -1:
+        failure_section = diagram[failure_section_start:]
+        # Should show primary failing, then fallback succeeding
+        assert "Fallback triggered" in failure_section or "fallback" in failure_section.lower()
diff --git a/tests/unit/test_saga_bootstrap.py b/tests/unit/test_saga_bootstrap.py
new file mode 100644
index 0000000..4e32173
--- /dev/null
+++ b/tests/unit/test_saga_bootstrap.py
@@ -0,0 +1,395 @@
+"""
+AAA unit tests for cqrs.saga.bootstrap.
+
+Covers setup_saga_mediator and bootstrap for SagaMediator (increased coverage).
+"""
+
+import dataclasses
+import typing
+
+import di
+import pytest
+
+import cqrs
+from cqrs import events
+from cqrs.container import di as di_container_impl
+from cqrs.message_brokers import devnull
+from cqrs.middlewares import logging as logging_middleware
+from cqrs.requests import bootstrap as requests_bootstrap
+from cqrs.requests.map import SagaMap
+from cqrs.saga import bootstrap
+from cqrs.saga.models import SagaContext
+from cqrs.saga.saga import Saga
+from cqrs.saga.storage.memory import MemorySagaStorage
+from cqrs.saga.storage.protocol import ISagaStorage
+
+
+# ---------------------------------------------------------------------------
+# Mock CQRSContainer for tests passing CQRSContainer (not di.Container)
+# ---------------------------------------------------------------------------
+
+
+class MockCQRSContainer:
+    """Minimal CQRSContainer implementation for bootstrap tests."""
+
+    def __init__(self) -> None:
+        self._external_container: typing.Any = None
+
+    @property
+    def external_container(self) -> typing.Any:
+        return self._external_container
+
+    def attach_external_container(self, container: typing.Any) -> None:
+        self._external_container = container
+
+    async def resolve(self, type_: type[typing.Any]) -> typing.Any:
+        return type_()
+
+
+# Stub saga context and saga for sagas_mapper (SagaMap.bind)
+@dataclasses.dataclass
+class _StubSagaContext(SagaContext):
+    id: str = ""
+
+
+class _StubSaga(Saga[_StubSagaContext]):
+    steps: typing.ClassVar[list] = []
+
+
+# Stub event/handler for domain_events_mapper
+class _StubEvent(events.DomainEvent, frozen=True):
+    pass
+
+
+class _StubEventHandler(events.EventHandler[_StubEvent]):
+    async def handle(self, event: _StubEvent) -> None:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Test setup_saga_mediator
+# ---------------------------------------------------------------------------
+
+
+class TestSetupSagaMediator:
+    """AAA tests for saga.bootstrap.setup_saga_mediator."""
+
+    def test_setup_saga_mediator_returns_saga_mediator(self) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = requests_bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+
+        # Act
+        mediator = bootstrap.setup_saga_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+        )
+
+        # Assert
+        assert isinstance(mediator, cqrs.SagaMediator)
+        assert mediator._dispatcher is not None
+        assert mediator._dispatcher._container is container
+        assert mediator._dispatcher._saga_map is not None
+
+    def test_setup_saga_mediator_with_sagas_mapper_registers_sagas(self) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = requests_bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+        saga_map_received: list[SagaMap] = []
+
+        def sagas_mapper(m: SagaMap) -> None:
+            saga_map_received.append(m)
+            m.bind(_StubSagaContext, _StubSaga)
+
+        # Act
+        mediator = bootstrap.setup_saga_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+            sagas_mapper=sagas_mapper,
+        )
+
+        # Assert
+        assert len(saga_map_received) == 1
+        assert mediator._dispatcher._saga_map is saga_map_received[0]
+
+    def test_setup_saga_mediator_with_custom_event_map_uses_provided_map(
+        self,
+    ) -> None:
+        # Arrange: non-empty EventMap (empty dict is falsy in mediator)
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = requests_bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+        custom_event_map = events.EventMap()
+        custom_event_map.bind(_StubEvent, _StubEventHandler)
+
+        # Act
+        mediator = bootstrap.setup_saga_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+            event_map=custom_event_map,
+        )
+
+        # Assert
+        assert mediator._event_processor._event_map is custom_event_map
+
+    def test_setup_saga_mediator_with_saga_storage_passes_to_mediator(
+        self,
+    ) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = requests_bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+        storage = MemorySagaStorage()
+
+        # Act
+        mediator = bootstrap.setup_saga_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+            saga_storage=storage,
+        )
+
+        # Assert
+        assert mediator._dispatcher._storage is storage
+
+    def test_setup_saga_mediator_with_max_concurrent_and_concurrent_enable(
+        self,
+    ) -> None:
+        # Arrange
+        container = di_container_impl.DIContainer()
+        container.attach_external_container(di.Container())
+        emitter = requests_bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+
+        # Act
+        mediator = bootstrap.setup_saga_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+            max_concurrent_event_handlers=7,
+            concurrent_event_handle_enable=False,
+        )
+
+        # Assert
+        assert mediator._event_processor._max_concurrent_event_handlers == 7
+        assert mediator._event_processor._concurrent_event_handle_enable is False
+
+    def test_setup_saga_mediator_with_cqrs_container(self) -> None:
+        # Arrange
+        container = MockCQRSContainer()
+        emitter = requests_bootstrap.setup_event_emitter(container)
+        middlewares = [logging_middleware.LoggingMiddleware()]
+
+        # Act
+        mediator = bootstrap.setup_saga_mediator(
+            emitter,
+            container,
+            middlewares=middlewares,
+        )
+
+        # Assert
+        assert isinstance(mediator, cqrs.SagaMediator)
+        assert mediator._dispatcher._container is container
+
+
+# ---------------------------------------------------------------------------
+# Test bootstrap (saga)
+# ---------------------------------------------------------------------------
+
+
+class TestBootstrapSaga:
+    """AAA tests for saga.bootstrap.bootstrap."""
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_di_container_returns_saga_mediator(
+        self,
+    ) -> None:
+        # Arrange
+        di_container = di.Container()
+
+        # Act
+        mediator = bootstrap.bootstrap(di_container=di_container)
+
+        # Assert
+        assert isinstance(mediator, cqrs.SagaMediator)
+        assert mediator._dispatcher is not None
+        assert mediator._event_processor is not None
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_cqrs_container_returns_saga_mediator(
+        self,
+    ) -> None:
+        # Arrange
+        container = MockCQRSContainer()
+
+        # Act
+        mediator = bootstrap.bootstrap(di_container=container)
+
+        # Assert
+        assert isinstance(mediator, cqrs.SagaMediator)
+        assert mediator._dispatcher._container is container
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_calls_on_startup_callables(self) -> None:
+        # Arrange
+        di_container = di.Container()
+        on_startup_called: list[int] = []
+
+        def on_startup_1() -> None:
+            on_startup_called.append(1)
+
+        def on_startup_2() -> None:
+            on_startup_called.append(2)
+
+        # Act
+        bootstrap.bootstrap(
+            di_container=di_container,
+            on_startup=[on_startup_1, on_startup_2],
+        )
+
+        # Assert
+        assert on_startup_called == [1, 2]
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_on_startup_none_does_not_fail(self) -> None:
+        # Arrange
+        di_container = di.Container()
+
+        # Act & Assert (no exception)
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            on_startup=None,
+        )
+        assert isinstance(mediator, cqrs.SagaMediator)
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_appends_logging_middleware_if_not_present(
+        self,
+    ) -> None:
+        # Arrange
+        di_container = di.Container()
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            middlewares=[],
+        )
+
+        # Assert
+        assert mediator._dispatcher._middleware_chain is not None
+        assert isinstance(mediator, cqrs.SagaMediator)
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_existing_logging_middleware_does_not_duplicate(
+        self,
+    ) -> None:
+        # Arrange
+        di_container = di.Container()
+        middlewares = [logging_middleware.LoggingMiddleware()]
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            middlewares=middlewares,
+        )
+
+        # Assert
+        assert isinstance(mediator, cqrs.SagaMediator)
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_custom_message_broker(self) -> None:
+        # Arrange
+        di_container = di.Container()
+        broker = devnull.DevnullMessageBroker()
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            message_broker=broker,
+        )
+
+        # Assert
+        assert mediator._event_processor._event_emitter is not None
+        assert mediator._event_processor._event_emitter._message_broker is broker
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_sagas_mapper(self) -> None:
+        # Arrange
+        di_container = di.Container()
+        saga_map_received: list[SagaMap] = []
+
+        def sagas_mapper(m: SagaMap) -> None:
+            saga_map_received.append(m)
+            m.bind(_StubSagaContext, _StubSaga)
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            sagas_mapper=sagas_mapper,
+        )
+
+        # Assert
+        assert len(saga_map_received) == 1
+        assert mediator._dispatcher._saga_map is saga_map_received[0]
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_domain_events_mapper(self) -> None:
+        # Arrange
+        di_container = di.Container()
+        event_map_received: list[events.EventMap] = []
+
+        def domain_events_mapper(m: events.EventMap) -> None:
+            event_map_received.append(m)
+            m.bind(_StubEvent, _StubEventHandler)
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            domain_events_mapper=domain_events_mapper,
+        )
+
+        # Assert
+        assert len(event_map_received) == 1
+        assert mediator._event_processor._event_map is event_map_received[0]
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_saga_storage(self) -> None:
+        # Arrange
+        di_container = di.Container()
+        storage: ISagaStorage = MemorySagaStorage()
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            saga_storage=storage,
+        )
+
+        # Assert
+        assert mediator._dispatcher._storage is storage
+
+    @pytest.mark.asyncio
+    async def test_bootstrap_with_max_concurrent_and_concurrent_enable(
+        self,
+    ) -> None:
+        # Arrange
+        di_container = di.Container()
+
+        # Act
+        mediator = bootstrap.bootstrap(
+            di_container=di_container,
+            max_concurrent_event_handlers=4,
+            concurrent_event_handle_enable=False,
+        )
+
+        # Assert
+        assert mediator._event_processor._max_concurrent_event_handlers == 4
+        assert mediator._event_processor._concurrent_event_handle_enable is False
diff --git a/tests/unit/test_streaming_dispatcher.py b/tests/unit/test_streaming_dispatcher.py
index 184859d..596afcc 100644
--- a/tests/unit/test_streaming_dispatcher.py
+++ b/tests/unit/test_streaming_dispatcher.py
@@ -4,6 +4,7 @@
 import pydantic
 import pytest
 
+import cqrs
 from cqrs.dispatcher import StreamingRequestDispatcher
 from cqrs.events import Event, NotificationEvent
 from cqrs.requests.map import RequestMap
@@ -29,13 +30,13 @@ def __init__(self) -> None:
         self._events: list[Event] = []
 
     @property
-    def events(self) -> list[Event]:
+    def events(self) -> typing.Sequence[cqrs.IEvent]:
         return self._events.copy()
 
     def clear_events(self) -> None:
         self._events.clear()
 
-    async def handle(  # type: ignore[override]
+    async def handle(
         self,
         request: ProcessItemsCommand,
     ) -> typing.AsyncIterator[ProcessItemResult]:
@@ -58,6 +59,25 @@ async def resolve(self, type_):
         return self._handler
 
 
+async def test_streaming_handler_handle_returns_async_iterator_consumable_with_async_for() -> None:
+    """
+    Contract: StreamingRequestHandler.handle(request) is called without await
+    and returns an AsyncIterator that is consumed with async for.
+    """
+    handler = AsyncStreamingHandler()
+    request = ProcessItemsCommand(item_ids=["a", "b"])
+    # handle() is called (no await) and returns async generator
+    async_gen = handler.handle(request)
+    # Can be iterated with async for
+    results = []
+    async for item in async_gen:
+        results.append(item)
+    assert len(results) == 2
+    assert results[0].item_id == "a"
+    assert results[1].item_id == "b"
+    assert handler.called
+
+
 async def test_async_streaming_dispatcher_logic() -> None:
     handler = AsyncStreamingHandler()
     request_map = RequestMap()
diff --git a/tests/unit/test_streaming_mediator.py b/tests/unit/test_streaming_mediator.py
index 70e621e..a75735b 100644
--- a/tests/unit/test_streaming_mediator.py
+++ b/tests/unit/test_streaming_mediator.py
@@ -1,5 +1,5 @@
+import asyncio
 import typing
-from unittest import mock
 
 import pydantic
 
@@ -12,7 +12,9 @@
     EventMap,
     NotificationEvent,
 )
+from cqrs.events.event import IEvent
 from cqrs.mediator import StreamingRequestMediator
+from cqrs.message_brokers import devnull
 from cqrs.requests.map import RequestMap
 from cqrs.requests.request import Request
 from cqrs.requests.request_handler import StreamingRequestHandler
@@ -34,13 +36,13 @@ def __init__(self) -> None:
         self._events: list[Event] = []
 
     @property
-    def events(self) -> list[Event]:
+    def events(self) -> typing.Sequence[IEvent]:
         return self._events.copy()
 
     def clear_events(self) -> None:
         self._events.clear()
 
-    async def handle(  # type: ignore
+    async def handle(
         self,
         request: ProcessItemsCommand,
     ) -> typing.AsyncIterator[ProcessItemResult]:
@@ -63,14 +65,63 @@ async def resolve(self, type_):
         return self._handler
 
 
+async def test_streaming_mediator_stream_returns_async_iterator_consumable_with_async_for() -> None:
+    """
+    Contract: mediator.stream(request) is called without await
+    and returns an AsyncIterator that is consumed with async for.
+    """
+    handler = StreamingHandler()
+    request_map = RequestMap()
+    request_map.bind(ProcessItemsCommand, StreamingHandler)
+    container = Container(handler)
+    event_map = EventMap()
+    message_broker = devnull.DevnullMessageBroker()
+    event_emitter = EventEmitter(
+        event_map=event_map,
+        container=container,  # type: ignore
+        message_broker=message_broker,
+    )
+    mediator = StreamingRequestMediator(
+        request_map=request_map,
+        container=container,  # type: ignore
+        event_emitter=event_emitter,
+    )
+    request = ProcessItemsCommand(item_ids=["a", "b"])
+    # stream() is called (no await) and returns async iterator
+    async_gen = mediator.stream(request)
+    results = []
+    async for item in async_gen:
+        results.append(item)
+    assert len(results) == 2
+    assert results[0].item_id == "a"
+    assert results[1].item_id == "b"
+    assert handler.called
+
+
 async def test_streaming_mediator_logic() -> None:
     handler = StreamingHandler()
     request_map = RequestMap()
     request_map.bind(ProcessItemsCommand, StreamingHandler)
     container = Container(handler)
 
-    event_emitter = mock.AsyncMock(spec=EventEmitter)
-    event_emitter.emit = mock.AsyncMock()
+    event_map = EventMap()
+    message_broker = devnull.DevnullMessageBroker()
+    event_emitter = EventEmitter(
+        event_map=event_map,
+        container=container,  # type: ignore
+        message_broker=message_broker,
+    )
+
+    # Track emit calls
+    original_emit = event_emitter.emit
+    emit_call_count = 0
+
+    async def tracked_emit(event):
+        nonlocal emit_call_count
+        emit_call_count += 1
+        return await original_emit(event)
+
+    event_emitter.emit = tracked_emit  # type: ignore[assignment]
 
     mediator = StreamingRequestMediator(
         request_map=request_map,
@@ -83,13 +134,16 @@ async def test_streaming_mediator_logic() -> None:
     async for result in mediator.stream(request):
         results.append(result)
 
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert handler.called
     assert len(results) == 3
     assert results[0].item_id == "item1"
     assert results[1].item_id == "item2"
     assert results[2].item_id == "item3"
 
-    assert event_emitter.emit.call_count == 3
+    assert emit_call_count == 3
 
 
 async def test_streaming_mediator_without_event_emitter() -> None:
@@ -124,8 +178,13 @@ async def test_streaming_mediator_events_order() -> None:
     async def mock_emit(event: Event):
         emitted_events.append(event)
 
-    event_emitter = mock.AsyncMock(spec=EventEmitter)
-    event_emitter.emit = mock_emit
+    message_broker = devnull.DevnullMessageBroker()
+    event_emitter = EventEmitter(
+        event_map=EventMap(),
+        container=container,  # type: ignore
+        message_broker=message_broker,
+    )
+    event_emitter.emit = mock_emit  # type: ignore[assignment]
 
     mediator = StreamingRequestMediator(
         request_map=request_map,
@@ -137,6 +196,8 @@ async def mock_emit(event: Event):
     results = []
     async for result in mediator.stream(request):
         results.append(result)
+        # Wait a bit for background task to complete
+        await asyncio.sleep(0.05)
         assert len(emitted_events) == len(results)
 
     assert len(emitted_events) == 2
@@ -146,7 +207,7 @@ async def mock_emit(event: Event):
     assert emitted_events[1].payload["item_id"] == "item2"  # type: ignore
 
 
-class ItemProcessedDomainEvent(DomainEvent):  # type: ignore[misc]
+class ItemProcessedDomainEvent(DomainEvent, frozen=True):
     item_id: str = pydantic.Field()
 
 
@@ -166,13 +227,13 @@ def __init__(self) -> None:
         self._events: list[Event] = []
 
     @property
-    def events(self) -> list[Event]:
+    def events(self) -> typing.Sequence[IEvent]:
         return self._events.copy()
 
     def clear_events(self) -> None:
         self._events.clear()
 
-    async def handle(  # type: ignore
+    async def handle(
         self,
         request: ProcessItemsCommand,
     ) -> typing.AsyncIterator[ProcessItemResult]:
@@ -194,23 +255,22 @@ async def test_streaming_mediator_processes_events_parallel() -> None:
     event_map = EventMap()
     event_map.bind(ItemProcessedDomainEvent, ItemProcessedEventHandler)
 
-    class EventContainer:
-        def __init__(self, handler):
-            self._handler = handler
-            self._external_container: typing.Any = None
-
-        @property
-        def external_container(self) -> typing.Any:
-            return self._external_container
+    event_container = Container(event_handler)
+    event_emitter = EventEmitter(
+        event_map=event_map,
+        container=event_container,  # type: ignore
+    )
 
-        def attach_external_container(self, container: typing.Any) -> None:
-            self._external_container = container
+    # Track emit calls
+    original_emit = event_emitter.emit
+    emit_call_count = 0
 
-        async def resolve(self, type_: typing.Type[typing.Any]) -> typing.Any:
-            return self._handler
+    async def tracked_emit(event):
+        nonlocal emit_call_count
+        emit_call_count += 1
+        return await original_emit(event)
 
-    event_emitter = mock.AsyncMock(spec=EventEmitter)
-    event_emitter.emit = mock.AsyncMock()
+    event_emitter.emit = tracked_emit  # type: ignore[assignment]
 
     mediator = StreamingRequestMediator(
         request_map=request_map,
@@ -220,19 +280,18 @@ async def resolve(self, type_: typing.Type[typing.Any]) -> typing.Any:
         max_concurrent_event_handlers=2,
     )
 
-    mediator._event_processor._event_dispatcher._container = EventContainer(
-        event_handler,
-    )  # type: ignore
-
     request = ProcessItemsCommand(item_ids=["item1", "item2", "item3"])
     results = []
     async for result in mediator.stream(request):
         results.append(result)
 
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert handler.called
     assert len(results) == 3
     assert len(event_handler.processed_events) == 3
-    assert event_emitter.emit.call_count == 3
+    assert emit_call_count == 3
 
 
 async def test_streaming_mediator_processes_events_sequentially() -> None:
@@ -245,23 +304,22 @@ async def test_streaming_mediator_processes_events_sequentially() -> None:
     event_map = EventMap()
     event_map.bind(ItemProcessedDomainEvent, ItemProcessedEventHandler)
 
-    class EventContainer:
-        def __init__(self, handler):
-            self._handler = handler
-            self._external_container: typing.Any = None
-
-        @property
-        def external_container(self) -> typing.Any:
-            return self._external_container
+    event_container = Container(event_handler)
+    event_emitter = EventEmitter(
+        event_map=event_map,
+        container=event_container,  # type: ignore
+    )
 
-        def attach_external_container(self, container: typing.Any) -> None:
-            self._external_container = container
+    # Track emit calls
+    original_emit = event_emitter.emit
+    emit_call_count = 0
 
-        async def resolve(self, type_: typing.Type[typing.Any]) -> typing.Any:
-            return self._handler
+    async def tracked_emit(event):
+        nonlocal emit_call_count
+        emit_call_count += 1
+        return await original_emit(event)
 
-    event_emitter = mock.AsyncMock(spec=EventEmitter)
-    event_emitter.emit = mock.AsyncMock()
+    event_emitter.emit = tracked_emit  # type: ignore[assignment]
 
     mediator = StreamingRequestMediator(
         request_map=request_map,
@@ -272,16 +330,15 @@ async def resolve(self, type_: typing.Type[typing.Any]) -> typing.Any:
         concurrent_event_handle_enable=False,
     )
 
-    mediator._event_processor._event_dispatcher._container = EventContainer(
-        event_handler,
-    )  # type: ignore
-
     request = ProcessItemsCommand(item_ids=["item1", "item2", "item3"])
     results = []
     async for result in mediator.stream(request):
         results.append(result)
 
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
     assert handler.called
     assert len(results) == 3
     assert len(event_handler.processed_events) == 3
-    assert event_emitter.emit.call_count == 3
+    assert emit_call_count == 3
diff --git a/tests/unit/test_streaming_outbox_background_processing.py b/tests/unit/test_streaming_outbox_background_processing.py
new file mode 100644
index 0000000..1b07977
--- /dev/null
+++ b/tests/unit/test_streaming_outbox_background_processing.py
@@ -0,0 +1,341 @@
+"""
+Test to reproduce the bug: '_asyncio.Future' object has no attribute 'handle'
+
+This test reproduces the scenario where:
+1. Events are processed from outbox in background
+2. StreamingRequestMediator is used with parallel event processing
+3. Events are emitted via EventEmitter which processes them in parallel
+4. The error occurs when trying to call .handle() on a Future object
+
+The bug likely occurs in EventProcessor.emit_events() when events are processed
+in parallel via asyncio.create_task(), and somewhere the code tries to call
+.handle() on the task result instead of the handler object.
+"""
+
+import asyncio
+import functools
+import logging
+import typing
+import uuid
+from collections import defaultdict
+
+import pydantic
+
+import cqrs
+from cqrs.events import DomainEvent, EventHandler, Event
+from cqrs.events.event import IEvent
+from cqrs.message_brokers import devnull
+from cqrs.outbox import mock
+from cqrs.requests import bootstrap
+from cqrs.requests.request import Request
+from cqrs.requests.request_handler import StreamingRequestHandler
+from cqrs.response import Response
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+# Mock storage for outbox
+OUTBOX_STORAGE = defaultdict[
+    uuid.UUID,
+    typing.List[cqrs.NotificationEvent],
+](lambda: [])
+
+
+# Test models
+class ProcessServiceCommand(Request):
+    service_id: str = pydantic.Field()
+
+
+class ProcessServiceResult(Response):
+    service_id: str = pydantic.Field()
+    status: str = pydantic.Field()
+
+
+class ServiceChangedDomainEvent(DomainEvent, frozen=True):
+    service_id: str = pydantic.Field()
+
+
+# Event handler that will be called
+class ServiceChangedEventHandler(EventHandler[ServiceChangedDomainEvent]):
+    def __init__(self) -> None:
+        self.handled_events: list[ServiceChangedDomainEvent] = []
+        self.call_count = 0
+
+    async def handle(self, event: ServiceChangedDomainEvent) -> None:
+        self.call_count += 1
+        self.handled_events.append(event)
+        logger.info(f"Handled event for service {event.service_id}")
+
+
+# Streaming handler that emits events
+class ProcessServiceStreamingHandler(
+    StreamingRequestHandler[ProcessServiceCommand, ProcessServiceResult],
+):
+    def __init__(self, outbox: cqrs.OutboxedEventRepository) -> None:
+        self.outbox = outbox
+        self.called = False
+        self._events: list[Event] = []
+
+    @property
+    def events(self) -> typing.Sequence[IEvent]:
+        return self._events.copy()
+
+    def clear_events(self) -> None:
+        self._events.clear()
+
+    async def handle(
+        self,
+        request: ProcessServiceCommand,
+    ) -> typing.AsyncIterator[ProcessServiceResult]:
+        self.called = True
+        logger.info(f"Processing service {request.service_id}")
+
+        # Emit domain event
+        event = ServiceChangedDomainEvent(service_id=request.service_id)
+        self._events.append(event)
+
+        result = ProcessServiceResult(
+            service_id=request.service_id,
+            status="processed",
+        )
+        yield result
+
+
+# Simple container
+class MockContainer:
+    def __init__(
+        self,
+        handler: ProcessServiceStreamingHandler | None = None,
+        event_handler: ServiceChangedEventHandler | None = None,
+    ) -> None:
+        self._handler = handler
+        self._event_handler = event_handler
+        self._handlers: dict[type, object] = {}
+
+    def register_handler(self, handler_type: type, handler_instance: object) -> None:
+        """Register a handler instance for a type."""
+        self._handlers[handler_type] = handler_instance
+
+    async def resolve(self, type_):
+        # Check registered handlers first
+        if type_ in self._handlers:
+            return self._handlers[type_]
+        # Fallback to old behavior for backward compatibility
+        if type_ == ProcessServiceStreamingHandler and self._handler:
+            return self._handler
+        if type_ == ServiceChangedEventHandler and self._event_handler:
+            return self._event_handler
+        return None
+
+
+async def test_streaming_outbox_background_processing_reproduces_bug():
+    """
+    Test that reproduces the bug when processing events from outbox in background.
+
+    This test simulates the scenario where:
+    1. A streaming handler processes a request and emits events
+    2. Events are processed in parallel via EventProcessor
+    3. Event handlers are called via EventEmitter
+    4. The bug occurs when trying to call .handle() on a Future object
+
+    Expected behavior: Events should be processed without errors.
+    Actual behavior: Error '_asyncio.Future' object has no attribute 'handle'
+    """
+    # Setup outbox repository
+    mock_repository_factory = functools.partial(
+        mock.MockOutboxedEventRepository,
+        session_factory=functools.partial(lambda: OUTBOX_STORAGE),
+    )
+    outbox_repository = mock_repository_factory()
+
+    # Create handlers
+    handler = ProcessServiceStreamingHandler(outbox_repository)
+    event_handler = ServiceChangedEventHandler()
+
+    # Create container
+    container = MockContainer(handler, event_handler)
+
+    # Setup mappers
+    def commands_mapper(mapper: cqrs.RequestMap) -> None:
+        mapper.bind(ProcessServiceCommand, ProcessServiceStreamingHandler)
+
+    def domain_events_mapper(mapper: cqrs.EventMap) -> None:
+        mapper.bind(ServiceChangedDomainEvent, ServiceChangedEventHandler)
+
+    # Create mediator with parallel event processing enabled
+    mediator = bootstrap.bootstrap_streaming(
+        di_container=container,  # type: ignore
+        commands_mapper=commands_mapper,
+        domain_events_mapper=domain_events_mapper,
+        message_broker=devnull.DevnullMessageBroker(),
+        max_concurrent_event_handlers=3,
+        concurrent_event_handle_enable=True,  # Enable parallel processing
+    )
+
+    # Process request
+    request = ProcessServiceCommand(service_id="service-1")
+    results = []
+    async for result in mediator.stream(request):
+        results.append(result)
+
+    # Wait for background tasks to complete
+    # This is where the bug might occur - background tasks might try to call .handle()
+    # on a Future object instead of the handler object
+    await asyncio.sleep(0.2)
+
+    # Verify results
+    assert handler.called
+    assert len(results) == 1
+    assert results[0].service_id == "service-1"
+
+    # Verify event handler was called
+    # This might fail if the bug occurs
+    assert event_handler.call_count == 1
+    assert len(event_handler.handled_events) == 1
+    assert event_handler.handled_events[0].service_id == "service-1"
+
+
+async def test_streaming_outbox_background_processing_sequential():
+    """
+    Test with sequential event processing (should work without errors).
+    """
+    # Setup outbox repository
+    mock_repository_factory = functools.partial(
+        mock.MockOutboxedEventRepository,
+        session_factory=functools.partial(lambda: OUTBOX_STORAGE),
+    )
+    outbox_repository = mock_repository_factory()
+
+    # Create handlers
+    handler = ProcessServiceStreamingHandler(outbox_repository)
+    event_handler = ServiceChangedEventHandler()
+
+    # Create container and register handlers
+    container = MockContainer(handler, event_handler)
+    container.register_handler(ProcessServiceStreamingHandler, handler)
+    container.register_handler(ServiceChangedEventHandler, event_handler)
+
+    # Setup mappers
+    def commands_mapper(mapper: cqrs.RequestMap) -> None:
+        mapper.bind(ProcessServiceCommand, ProcessServiceStreamingHandler)
+
+    def domain_events_mapper(mapper: cqrs.EventMap) -> None:
+        mapper.bind(ServiceChangedDomainEvent, ServiceChangedEventHandler)
+
+    # Create mediator with sequential event processing
+    mediator = bootstrap.bootstrap_streaming(
+        di_container=container,  # type: ignore
+        commands_mapper=commands_mapper,
+        domain_events_mapper=domain_events_mapper,
+        message_broker=devnull.DevnullMessageBroker(),
+        max_concurrent_event_handlers=1,
+        concurrent_event_handle_enable=False,  # Sequential processing
+    )
+
+    # Process request
+    request = ProcessServiceCommand(service_id="service-1")
+    results = []
+    async for result in mediator.stream(request):
+        results.append(result)
+
+    # Wait for background tasks to complete
+    await asyncio.sleep(0.1)
+
+    # Verify results
+    assert handler.called
+    assert len(results) == 1
+    assert results[0].service_id == "service-1"
+
+    # Verify event handler was called
+    assert event_handler.call_count == 1
+    assert len(event_handler.handled_events) == 1
+    assert event_handler.handled_events[0].service_id == "service-1"
+
+
+async def test_streaming_outbox_multiple_events_parallel():
+    """
+    Test with multiple events processed in parallel (more likely to trigger the bug).
+    """
+    # Setup outbox repository
+    mock_repository_factory = functools.partial(
+        mock.MockOutboxedEventRepository,
+        session_factory=functools.partial(lambda: OUTBOX_STORAGE),
+    )
+    outbox_repository = mock_repository_factory()
+
+    # Create a handler that emits multiple events
+    class MultiEventStreamingHandler(
+        StreamingRequestHandler[ProcessServiceCommand, ProcessServiceResult],
+    ):
+        def __init__(self, outbox: cqrs.OutboxedEventRepository) -> None:
+            self.outbox = outbox
+            self.called = False
+            self._events: list[Event] = []
+
+        @property
+        def events(self) -> typing.Sequence[IEvent]:
+            return self._events.copy()
+
+        def clear_events(self) -> None:
+            self._events.clear()
+
+        async def handle(
+            self,
+            request: ProcessServiceCommand,
+        ) -> typing.AsyncIterator[ProcessServiceResult]:
+            self.called = True
+            # Emit multiple events
+            for i in range(3):
+                event = ServiceChangedDomainEvent(
+                    service_id=f"{request.service_id}-{i}",
+                )
+                self._events.append(event)
+                result = ProcessServiceResult(
+                    service_id=f"{request.service_id}-{i}",
+                    status="processed",
+                )
+                yield result
+
+    handler = MultiEventStreamingHandler(outbox_repository)
+    event_handler = ServiceChangedEventHandler()
+
+    # Create container and register handlers
+    container = MockContainer()
+    container.register_handler(MultiEventStreamingHandler, handler)
+    container.register_handler(ServiceChangedEventHandler, event_handler)
+
+    # Setup mappers
+    def commands_mapper(mapper: cqrs.RequestMap) -> None:
+        mapper.bind(ProcessServiceCommand, MultiEventStreamingHandler)
+
+    def domain_events_mapper(mapper: cqrs.EventMap) -> None:
+        mapper.bind(ServiceChangedDomainEvent, ServiceChangedEventHandler)
+
+    # Create mediator with parallel event processing
+    mediator = bootstrap.bootstrap_streaming(
+        di_container=container,  # type: ignore
+        commands_mapper=commands_mapper,
+        domain_events_mapper=domain_events_mapper,
+        message_broker=devnull.DevnullMessageBroker(),
+        max_concurrent_event_handlers=5,
+        concurrent_event_handle_enable=True,  # Parallel processing
+    )
+
+    # Process request
+    request = ProcessServiceCommand(service_id="service-1")
+    results = []
+    async for result in mediator.stream(request):
+        results.append(result)
+
+    # Wait for background tasks to complete
+    # This is where the bug is most likely to occur
+    await asyncio.sleep(0.3)
+
+    # Verify results
+    assert handler.called
+    assert len(results) == 3
+
+    # Verify event handler was called for all events
+    # This might fail if the bug occurs
+    assert event_handler.call_count == 3
+    assert len(event_handler.handled_events) == 3