edda-framework 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

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/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:
         """

{edda_framework-0.5.0.dist-info → edda_framework-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edda-framework
-Version: 0.5.0
+Version: 0.6.0
 Summary: Lightweight Durable Execution Framework
 Project-URL: Homepage, https://github.com/i2y/edda
 Project-URL: Documentation, https://github.com/i2y/edda#readme
@@ -709,7 +709,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 +748,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.dist-info → edda_framework-0.6.0.dist-info}/RECORD

@@ -14,8 +14,8 @@ edda/workflow.py,sha256=daSppYAzgXkjY_9-HS93Zi7_tPR6srmchxY5YfwgU-4,7239
 edda/wsgi.py,sha256=1pGE5fhHpcsYnDR8S3NEFKWUs5P0JK4roTAzX9BsIj0,2391
 edda/integrations/__init__.py,sha256=F_CaTvlDEbldfOpPKq_U9ve1E573tS6XzqXnOtyHcXI,33
 edda/integrations/mcp/__init__.py,sha256=YK-8m0DIdP-RSqewlIX7xnWU7TD3NioCiW2_aZSgnn8,1232
-edda/integrations/mcp/decorators.py,sha256=UTBb-Un2JK938pDZmANOvfsdKOMI2AF9yGtfSuy8VrE,6284
-edda/integrations/mcp/server.py,sha256=pzCG46Zko9hHmQ3REbo1w3A23SjrGFLiZupwSkIPhOA,13942
+edda/integrations/mcp/decorators.py,sha256=31SmbDwmHEGvUNa3aaatW91hBkpnS5iN9uy47dID3J4,10037
+edda/integrations/mcp/server.py,sha256=Q5r4AbMn-9gBcy2CZocbgW7O0fn7Qb4e9CBJa1FEmzU,14507
 edda/integrations/opentelemetry/__init__.py,sha256=x1_PyyygGDW-rxQTwoIrGzyjKErXHOOKdquFAMlCOAo,906
 edda/integrations/opentelemetry/hooks.py,sha256=FBYnSZBh8_0vw9M1E2AbJrx1cTTsKeiHf5wspr0UnzU,21288
 edda/outbox/__init__.py,sha256=azXG1rtheJEjOyoWmMsBeR2jp8Bz02R3wDEd5tQnaWA,424
@@ -35,8 +35,8 @@ edda/viewer_ui/data_service.py,sha256=mXV6bL6REa_UKsk8xMGBIFbsbLpIxe91lX3wgn-FOj
 edda/visualizer/__init__.py,sha256=DOpDstNhR0VcXAs_eMKxaL30p_0u4PKZ4o2ndnYhiRo,343
 edda/visualizer/ast_analyzer.py,sha256=plmx7C9X_X35xLY80jxOL3ljg3afXxBePRZubqUIkxY,13663
 edda/visualizer/mermaid_generator.py,sha256=XWa2egoOTNDfJEjPcwoxwQmblUqXf7YInWFjFRI1QGo,12457
-edda_framework-0.5.0.dist-info/METADATA,sha256=GfZ0zYUy_g4zjV_OkYPPmNRTwIxZb77nh-aaS6Z_OYE,31503
-edda_framework-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-edda_framework-0.5.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
-edda_framework-0.5.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
-edda_framework-0.5.0.dist-info/RECORD,,
+edda_framework-0.6.0.dist-info/METADATA,sha256=sxR8GtZNOzswVHIh8n_uAojtOrUEn_mXbT9Li5IvTnk,31702
+edda_framework-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+edda_framework-0.6.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
+edda_framework-0.6.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
+edda_framework-0.6.0.dist-info/RECORD,,