edda-framework 0.5.0__tar.gz → 0.7.0__tar.gz

{edda_framework-0.5.0 → edda_framework-0.7.0}/.github/workflows/ci.yml

@@ -53,8 +53,8 @@ jobs:
       - name: Set up Python ${{ matrix.python-version }}
         run: uv python install ${{ matrix.python-version }}
 
-      - name: Install dependencies (all database drivers)
-        run: uv sync --extra dev --extra postgresql --extra mysql
+      - name: Install dependencies (all database drivers and opentelemetry)
+        run: uv sync --extra dev --extra postgresql --extra mysql --extra opentelemetry
 
       - name: Run tests (all databases)
         env:

{edda_framework-0.5.0 → edda_framework-0.7.0}/.gitignore

@@ -99,3 +99,4 @@ site/
 
 # Cache directories
 .cache/
+.nicegui/

{edda_framework-0.5.0 → edda_framework-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edda-framework
-Version: 0.5.0
+Version: 0.7.0
 Summary: Lightweight Durable Execution Framework
 Project-URL: Homepage, https://github.com/i2y/edda
 Project-URL: Documentation, https://github.com/i2y/edda#readme
@@ -30,11 +30,13 @@ Requires-Dist: sqlalchemy[asyncio]>=2.0.0
 Requires-Dist: uvloop>=0.22.1
 Provides-Extra: dev
 Requires-Dist: black>=25.9.0; extra == 'dev'
+Requires-Dist: mcp>=1.22.0; extra == 'dev'
 Requires-Dist: mypy>=1.18.2; extra == 'dev'
 Requires-Dist: pytest-asyncio>=1.2.0; extra == 'dev'
 Requires-Dist: pytest-cov>=7.0.0; extra == 'dev'
 Requires-Dist: pytest>=8.4.2; extra == 'dev'
 Requires-Dist: ruff>=0.14.2; extra == 'dev'
+Requires-Dist: starlette>=0.40.0; extra == 'dev'
 Requires-Dist: testcontainers[mysql]>=4.0.0; extra == 'dev'
 Requires-Dist: testcontainers[postgres]>=4.0.0; extra == 'dev'
 Requires-Dist: tsuno>=0.1.3; extra == 'dev'
@@ -709,7 +711,7 @@ def process_payment(ctx: WorkflowContext, amount: float) -> dict:
 @workflow
 async def payment_workflow(ctx: WorkflowContext, order_id: str) -> dict:
     # Workflows still use async (for deterministic replay)
-    result = await process_payment(ctx, 99.99, activity_id="pay:1")
+    result = await process_payment(ctx, 99.99)
     return result
 ```
 
@@ -748,13 +750,14 @@ if __name__ == "__main__":
 
 ### Auto-Generated Tools
 
-Each `@durable_tool` automatically generates **three MCP tools**:
+Each `@durable_tool` automatically generates **four MCP tools**:
 
 1. **Main tool** (`process_order`): Starts the workflow, returns instance ID
-2. **Status tool** (`process_order_status`): Checks workflow progress
+2. **Status tool** (`process_order_status`): Checks workflow progress with completed activity count and suggested poll interval
 3. **Result tool** (`process_order_result`): Gets final result when completed
+4. **Cancel tool** (`process_order_cancel`): Cancels workflow if running or waiting, executes compensation handlers
 
-This enables AI assistants to work with workflows that take minutes, hours, or even days to complete.
+This enables AI assistants to work with workflows that take minutes, hours, or even days to complete, with full control over the workflow lifecycle.
 
 ### MCP Prompts
 

{edda_framework-0.5.0 → edda_framework-0.7.0}/README.md

@@ -653,7 +653,7 @@ def process_payment(ctx: WorkflowContext, amount: float) -> dict:
 @workflow
 async def payment_workflow(ctx: WorkflowContext, order_id: str) -> dict:
     # Workflows still use async (for deterministic replay)
-    result = await process_payment(ctx, 99.99, activity_id="pay:1")
+    result = await process_payment(ctx, 99.99)
     return result
 ```
 
@@ -692,13 +692,14 @@ if __name__ == "__main__":
 
 ### Auto-Generated Tools
 
-Each `@durable_tool` automatically generates **three MCP tools**:
+Each `@durable_tool` automatically generates **four MCP tools**:
 
 1. **Main tool** (`process_order`): Starts the workflow, returns instance ID
-2. **Status tool** (`process_order_status`): Checks workflow progress
+2. **Status tool** (`process_order_status`): Checks workflow progress with completed activity count and suggested poll interval
 3. **Result tool** (`process_order_result`): Gets final result when completed
+4. **Cancel tool** (`process_order_cancel`): Cancels workflow if running or waiting, executes compensation handlers
 
-This enables AI assistants to work with workflows that take minutes, hours, or even days to complete.
+This enables AI assistants to work with workflows that take minutes, hours, or even days to complete, with full control over the workflow lifecycle.
 
 ### MCP Prompts
 

{edda_framework-0.5.0 → edda_framework-0.7.0}/docs/index.md

@@ -46,6 +46,7 @@ Edda's waiting functions make it ideal for time-based and event-driven business
 - **📦 Scheduled Notifications**: Shipping updates, subscription renewals, appointment reminders
 
 **Waiting functions**:
+
 - `wait_timer(duration_seconds)`: Wait for a relative duration
 - `wait_until(until_time)`: Wait until an absolute datetime (e.g., campaign end date)
 - `wait_event(event_type)`: Wait for external events (near real-time response)

{edda_framework-0.5.0 → edda_framework-0.7.0}/docs/integrations/mcp.md

@@ -7,10 +7,11 @@ Edda provides seamless integration with the [Model Context Protocol (MCP)](https
 MCP is a standardized protocol for AI tool integration. Edda's MCP integration automatically converts your durable workflows into MCP-compliant tools that:
 
 - **Start workflows** and return instance IDs immediately
-- **Check workflow status** to monitor progress
+- **Check workflow status** to monitor progress with completed activity count and suggested poll interval
 - **Retrieve results** when workflows complete
+- **Cancel workflows** if running or waiting, with automatic compensation execution
 
-This enables AI assistants to work with long-running processes that may take minutes, hours, or even days to complete.
+This enables AI assistants to work with long-running processes that may take minutes, hours, or even days to complete, with full control over the workflow lifecycle.
 
 ## Installation
 
@@ -97,7 +98,7 @@ Add to your MCP client configuration (e.g., Claude Desktop: `~/Library/Applicati
 
 ## Auto-Generated Tools
 
-Each `@durable_tool` automatically generates **three MCP tools**:
+Each `@durable_tool` automatically generates **four MCP tools**:
 
 ### 1. Main Tool: Start Workflow
 
@@ -125,12 +126,17 @@ Input: {"instance_id": "abc123..."}
 Output: {
   "content": [{
     "type": "text",
-    "text": "Workflow Status: running\nCurrent Activity: payment:1\nInstance ID: abc123..."
+    "text": "Workflow Status: running\nCurrent Activity: payment:1\nCompleted Activities: 1\nSuggested Poll Interval: 5000ms\nInstance ID: abc123..."
   }],
   "isError": false
 }
 ```
 
+The status tool provides progress metadata for efficient polling:
+
+- **Completed Activities**: Number of activities that have finished
+- **Suggested Poll Interval**: Recommended wait time before checking again (5000ms for running, 10000ms for waiting)
+
 ### 3. Result Tool: Get Final Result
 
 ```
@@ -147,6 +153,28 @@ Output: {
 }
 ```
 
+### 4. Cancel Tool: Stop Workflow
+
+```
+Tool Name: process_order_cancel
+Description: Cancel process_order workflow (if running or waiting)
+
+Input: {"instance_id": "abc123..."}
+Output: {
+  "content": [{
+    "type": "text",
+    "text": "Workflow 'process_order' cancelled successfully.\nInstance ID: abc123...\nCompensations executed.\n\nThe workflow has been stopped and any side effects have been rolled back."
+  }],
+  "isError": false
+}
+```
+
+The cancel tool:
+
+- Only works on workflows with status `running`, `waiting_for_event`, or `waiting_for_timer`
+- Automatically executes SAGA compensation transactions to roll back side effects
+- Returns an error for already completed, failed, or cancelled workflows
+
 ## Advanced Configuration
 
 ### Authentication

{edda_framework-0.5.0 → edda_framework-0.7.0}/docs/integrations/opentelemetry.md

@@ -76,11 +76,13 @@ workflow:order_workflow (parent)
 ## Span Attributes
 
 **Workflow Spans**:
+
 - `edda.workflow.instance_id`
 - `edda.workflow.name`
 - `edda.workflow.cancelled` (when cancelled)
 
 **Activity Spans**:
+
 - `edda.activity.id` (e.g., "reserve_inventory:1")
 - `edda.activity.name`
 - `edda.activity.is_replaying`
@@ -107,10 +109,12 @@ When `enable_metrics=True`:
 OpenTelemetryHooks automatically inherits trace context from multiple sources, with the following priority:
 
 1. **Explicit `_trace_context` in input_data** (highest priority)
+
    - Extracted from CloudEvents extension attributes
    - Useful for cross-service trace propagation
 
 2. **Current active span** (e.g., from ASGI/WSGI middleware)
+
    - Automatically detected using `trace.get_current_span()`
    - Works with OpenTelemetry instrumentation middleware
 

{edda_framework-0.5.0 → edda_framework-0.7.0}/docs/viewer-ui/setup.md

@@ -44,6 +44,16 @@ Then open http://localhost:8080 in your browser.
 
 *The Viewer UI shows all workflow instances with status badges and action buttons*
 
+**Pydantic Form Generation:**
+
+![Pydantic Form Generation](images/start-workflow-form-pydantic.png)
+
+*Auto-generated form fields based on Pydantic model type hints (str, float, int)*
+
+![Workflow Selection](images/workflow-selection-dropdown.png)
+
+*Dropdown showing all registered workflows with event_handler=True*
+
 ## Three Ways to Run the Viewer
 
 ### Method 1: Command Line (Recommended)
@@ -295,7 +305,7 @@ lsof -ti:8080 | xargs kill -9
 
 Once workflows appear, you'll see them with color-coded status badges:
 
-![Status Badges Example](images/status-badges-example.png)
+![Status Badges Example](images/workflow-list-view.png)
 
 *Workflow instances displayed with status badges (Completed ✅, Running ⏳, Failed ❌, Waiting ⏸️, Cancelled 🚫, etc.)*
 

{edda_framework-0.5.0 → edda_framework-0.7.0}/docs/viewer-ui/visualization.md

@@ -34,15 +34,22 @@ The Edda Viewer UI provides workflow visualization and monitoring.
 
 Workflows with conditional logic (if/else, match/case) are visualized with labeled branches:
 
-![Conditional Branching Diagram](images/conditional-branching-diagram.png)
+![Workflow Detail Page](images/detail-page-loan-approval.png)
 
-*Example: `loan_approval_workflow` showing conditional branches based on credit score ("sufficient" vs "insufficient" paths)*
+*Example: `loan_approval_workflow` detail page. Note the **Execution Flow diagram** (bottom left) showing conditional branches with "sufficient" vs "insufficient" paths based on credit score.*
 
 The diagram clearly shows:
+
 - Decision points (diamond shapes in some diagrams)
 - Branch labels indicating conditions
 - Different execution paths based on runtime data
 
+**Match/Case Pattern:**
+
+![Match Case Workflow](images/detail-page-match-case.png)
+
+*Example: `match_case_workflow` showing multiple case branches with different handlers*
+
 ## Viewing Workflows
 
 ### Workflow List
@@ -68,42 +75,46 @@ The main page shows all workflow instances:
 - 🚫 **Cancelled**: Manually cancelled (orange)
 - 🔄 **Compensating**: Executing compensations (purple)
 
-![Status Badges Example](images/status-badges-example.png)
+![Status Badges Example](images/workflow-list-view.png)
 
 ### Workflow List View
 
-The main page displays workflow instances as interactive cards:
+The main page displays workflow instances as interactive cards with search and filter capabilities:
 
 ![Workflow List View](images/workflow-list-view.png)
 
+*Workflow list with search filter bar, status filter, date range picker, and pagination controls*
+
 ### Workflow Detail Page
 
-Click on a workflow instance to see:
+Click on a workflow instance to see the detail page:
+
+![Workflow Detail Page](images/detail-page-loan-approval.png)
 
-1. **Overview Panel**:
-   - Instance ID, status, timestamps
-   - Input parameters (JSON)
-   - Output result (if completed)
+*Workflow detail page showing the Overview Panel (top), Execution Flow diagram (bottom left), and Activity Details panel (bottom right).*
 
-![Workflow Detail - Overview Panel](images/detail-overview-panel.png)
+1. **Overview Panel** (top):
 
-2. **Hybrid Diagram**:
-   - Visual graph of workflow structure
-   - Color-coded execution status
-   - Compensation flow (if applicable)
+      - Instance ID, status, timestamps
+      - Input parameters (JSON)
+      - Output result (if completed)
 
-![Hybrid Diagram Example](images/hybrid-diagram-example.png)
+2. **Execution Flow** (bottom left):
 
-3. **Execution History**:
-   - Step-by-step execution log
-   - Activity results
-   - Event data (for wait_event)
-   - Error messages (if failed)
+      - Visual graph of workflow structure
+      - Color-coded execution status
+      - Compensation flow (if applicable)
 
-![Execution History Panel](images/execution-history-panel.png)
+3. **Activity Details** (bottom right):
+
+      - Step-by-step execution log
+      - Activity results
+      - Event data (for wait_event)
+      - Error messages (if failed)
 
 4. **Actions**:
-   - **Cancel**: Stop running workflow
+
+      - **Cancel**: Stop running workflow
 
 ## Starting Workflows from Viewer
 
@@ -113,21 +124,15 @@ The Viewer UI can start workflows with automatic form generation:
 
 For Pydantic-based workflows, the Viewer generates input forms automatically.
 
-![Start Workflow Dialog](images/start-workflow-dialog.png)
+![Start Workflow Dialog](images/workflow-selection-dropdown.png)
 
-*Example: Workflow selection with auto-generated form*
+*Example: Workflow selection dropdown showing all registered workflows*
 
 The form generator supports various field types based on Pydantic model definitions:
 
-![Form Generation Example](images/form-generation-example.png)
-
-*Example: Auto-generated form showing different field types (text inputs, number inputs, checkboxes, etc.)*
-
-For complex workflows with nested models:
-
 ![Nested Pydantic Form](images/nested-pydantic-form.png)
 
-*Example: Auto-generated form with nested Pydantic models (OrderItem list, ShippingAddress)*
+*Auto-generated form with nested Pydantic models (items list, shipping_address) showing text inputs, number inputs, and nested model containers*
 
 ### Starting Workflow
 
@@ -166,7 +171,7 @@ When a workflow is cancelled or fails, and compensations run, the diagram shows:
 
 ![Compensation Execution](images/compensation-execution.png)
 
-*Example: `cancellable_booking` workflow after cancellation*
+*Saga compensation flow showing rollback activities (cancel_flight_ticket, cancel_hotel_room)*
 
 ## Event Waiting Visualization
 
@@ -174,7 +179,7 @@ Workflows can wait for external events using `wait_event()`. The Viewer displays
 
 ![Event Waiting Visualization](images/wait-event-visualization.png)
 
-*Example: `payment_workflow` waiting for `payment.completed` event*
+*Workflow with wait_event showing event type, timeout, and activity details panel*
 
 The diagram shows:
 - Hexagon node: Event wait point

{edda_framework-0.5.0 → edda_framework-0.7.0}/edda/integrations/mcp/decorators.py

@@ -19,14 +19,15 @@ def create_durable_tool(
     description: str = "",
 ) -> Workflow:
     """
-    Create a durable workflow tool with auto-generated status/result tools.
+    Create a durable workflow tool with auto-generated status/result/cancel tools.
 
     This function:
     1. Wraps the function as an Edda @workflow
-    2. Registers three MCP tools:
+    2. Registers four MCP tools:
        - {name}: Start workflow, return instance_id
        - {name}_status: Check workflow status
        - {name}_result: Get workflow result
+       - {name}_cancel: Cancel workflow (if running or waiting)
 
     Args:
         server: EddaMCPServer instance
@@ -93,9 +94,9 @@ def create_durable_tool(
     status_tool_name = f"{workflow_name}_status"
     status_tool_description = f"Check status of {workflow_name} workflow"
 
-    @server._mcp.tool(name=status_tool_name, description=status_tool_description)  # type: ignore[misc]
+    @server._mcp.tool(name=status_tool_name, description=status_tool_description)
     async def status_tool(instance_id: str) -> dict[str, Any]:
-        """Check workflow status."""
+        """Check workflow status with progress metadata."""
         try:
             instance = await server.storage.get_instance(instance_id)
             if instance is None:
@@ -112,9 +113,22 @@ def create_durable_tool(
             status = instance["status"]
             current_activity_id = instance.get("current_activity_id", "N/A")
 
+            # Get history to count completed activities
+            history = await server.storage.get_history(instance_id)
+            completed_activities = len(
+                [h for h in history if h["event_type"] == "ActivityCompleted"]
+            )
+
+            # Suggest poll interval based on status
+            # Running workflows need more frequent polling (5s)
+            # Waiting workflows need less frequent polling (10s)
+            suggested_poll_interval_ms = 5000 if status == "running" else 10000
+
             status_text = (
                 f"Workflow Status: {status}\n"
                 f"Current Activity: {current_activity_id}\n"
+                f"Completed Activities: {completed_activities}\n"
+                f"Suggested Poll Interval: {suggested_poll_interval_ms}ms\n"
                 f"Instance ID: {instance_id}"
             )
 
@@ -137,7 +151,7 @@ def create_durable_tool(
     result_tool_name = f"{workflow_name}_result"
     result_tool_description = f"Get result of {workflow_name} workflow (if completed)"
 
-    @server._mcp.tool(name=result_tool_name, description=result_tool_description)  # type: ignore[misc]
+    @server._mcp.tool(name=result_tool_name, description=result_tool_description)
     async def result_tool(instance_id: str) -> dict[str, Any]:
         """Get workflow result (if completed)."""
         try:
@@ -184,4 +198,86 @@ def create_durable_tool(
                 "isError": True,
             }
 
+    # 5. Generate cancel tool
+    cancel_tool_name = f"{workflow_name}_cancel"
+    cancel_tool_description = f"Cancel {workflow_name} workflow (if running or waiting)"
+
+    @server._mcp.tool(name=cancel_tool_name, description=cancel_tool_description)
+    async def cancel_tool(instance_id: str) -> dict[str, Any]:
+        """Cancel a running or waiting workflow."""
+        try:
+            # Check if instance exists
+            instance = await server.storage.get_instance(instance_id)
+            if instance is None:
+                return {
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": f"Workflow instance not found: {instance_id}",
+                        }
+                    ],
+                    "isError": True,
+                }
+
+            current_status = instance["status"]
+
+            # Check if replay_engine is available
+            if server.replay_engine is None:
+                return {
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": "Server not initialized. Call server.initialize() first.",
+                        }
+                    ],
+                    "isError": True,
+                }
+
+            # Try to cancel
+            success = await server.replay_engine.cancel_workflow(
+                instance_id=instance_id,
+                cancelled_by="mcp_user",
+            )
+
+            if success:
+                return {
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": (
+                                f"Workflow '{workflow_name}' cancelled successfully.\n"
+                                f"Instance ID: {instance_id}\n"
+                                f"Compensations executed.\n\n"
+                                f"The workflow has been stopped and any side effects "
+                                f"have been rolled back."
+                            ),
+                        }
+                    ],
+                    "isError": False,
+                }
+            else:
+                return {
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": (
+                                f"Cannot cancel workflow: {instance_id}\n"
+                                f"Current status: {current_status}\n"
+                                f"Only running or waiting workflows can be cancelled."
+                            ),
+                        }
+                    ],
+                    "isError": True,
+                }
+        except Exception as e:
+            return {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": f"Error cancelling workflow: {str(e)}",
+                    }
+                ],
+                "isError": True,
+            }
+
     return workflow_instance

{edda_framework-0.5.0 → edda_framework-0.7.0}/edda/integrations/mcp/server.py

@@ -9,10 +9,11 @@ from edda.app import EddaApp
 from edda.workflow import Workflow
 
 if TYPE_CHECKING:
+    from edda.replay import ReplayEngine
     from edda.storage.protocol import StorageProtocol
 
 try:
-    from mcp.server.fastmcp import FastMCP  # type: ignore[import-not-found]
+    from mcp.server.fastmcp import FastMCP
 except ImportError as e:
     raise ImportError(
         "MCP Python SDK is required for MCP integration. "
@@ -68,10 +69,11 @@ class EddaMCPServer:
             asyncio.run(main())
         ```
 
-    The server automatically generates three MCP tools for each @durable_tool:
+    The server automatically generates four MCP tools for each @durable_tool:
     - `tool_name`: Start the workflow, returns instance_id
     - `tool_name_status`: Check workflow status
     - `tool_name_result`: Get workflow result (if completed)
+    - `tool_name_cancel`: Cancel workflow (if running or waiting)
     """
 
     def __init__(
@@ -122,6 +124,24 @@ class EddaMCPServer:
         """
         return self._edda_app.storage
 
+    @property
+    def replay_engine(self) -> ReplayEngine | None:
+        """
+        Access replay engine for workflow operations (cancel, resume, etc.).
+
+        Returns:
+            ReplayEngine or None if not initialized
+
+        Example:
+            ```python
+            # Cancel a running workflow
+            success = await server.replay_engine.cancel_workflow(
+                instance_id, "mcp_user"
+            )
+            ```
+        """
+        return self._edda_app.replay_engine
+
     def durable_tool(
         self,
         func: Callable[..., Any] | None = None,
@@ -131,10 +151,11 @@ class EddaMCPServer:
         """
         Decorator to define a durable workflow tool.
 
-        Automatically generates three MCP tools:
+        Automatically generates four MCP tools:
         1. Main tool: Starts the workflow, returns instance_id
         2. Status tool: Checks workflow status
         3. Result tool: Gets workflow result (if completed)
+        4. Cancel tool: Cancels workflow (if running or waiting)
 
         Args:
             func: Workflow function (async)
@@ -207,7 +228,7 @@ class EddaMCPServer:
         def decorator(f: Callable[..., Any]) -> Callable[..., Any]:
             # Use FastMCP's native prompt decorator
             prompt_desc = description or f.__doc__ or f"Prompt: {f.__name__}"
-            return cast(Callable[..., Any], self._mcp.prompt(description=prompt_desc)(f))
+            return self._mcp.prompt(description=prompt_desc)(f)
 
         if func is None:
             return decorator
@@ -228,8 +249,8 @@ class EddaMCPServer:
         Returns:
             ASGI callable (Starlette app)
         """
-        from starlette.requests import Request  # type: ignore[import-not-found]
-        from starlette.responses import Response  # type: ignore[import-not-found]
+        from starlette.requests import Request
+        from starlette.responses import Response
 
         # Get MCP's Starlette app (Issue #1367 workaround: use directly)
         app = self._mcp.streamable_http_app()
@@ -270,14 +291,13 @@ class EddaMCPServer:
         app.router.add_route("/cancel/{instance_id}", edda_cancel_handler, methods=["POST"])
 
         # Add authentication middleware if token_verifier provided (AFTER adding routes)
+        result_app: Any = app
         if self._token_verifier is not None:
-            from starlette.middleware.base import (  # type: ignore[import-not-found]
-                BaseHTTPMiddleware,
-            )
+            from starlette.middleware.base import BaseHTTPMiddleware
 
-            class AuthMiddleware(BaseHTTPMiddleware):  # type: ignore[misc]
-                def __init__(self, app: Any, token_verifier: Callable[[str], bool]):
-                    super().__init__(app)
+            class AuthMiddleware(BaseHTTPMiddleware):
+                def __init__(self, app_inner: Any, token_verifier: Callable[[str], bool]) -> None:
+                    super().__init__(app_inner)
                     self.token_verifier = token_verifier
 
                 async def dispatch(
@@ -288,12 +308,13 @@ class EddaMCPServer:
                         token = auth_header[7:]
                         if not self.token_verifier(token):
                             return Response("Unauthorized", status_code=401)
-                    return await call_next(request)
+                    response: Response = await call_next(request)
+                    return response
 
             # Wrap app with auth middleware
-            app = AuthMiddleware(app, self._token_verifier)
+            result_app = AuthMiddleware(app, self._token_verifier)
 
-        return cast(Callable[..., Any], app)
+        return cast(Callable[..., Any], result_app)
 
     async def initialize(self) -> None:
         """