edda-framework 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

edda/integrations/mcp/decorators.py

@@ -6,11 +6,10 @@ import inspect
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any, cast
 
-from edda.workflow import workflow
+from edda.workflow import Workflow, workflow
 
 if TYPE_CHECKING:
     from edda.integrations.mcp.server import EddaMCPServer
-    from edda.workflow import Workflow
 
 
 def create_durable_tool(
@@ -98,7 +97,7 @@ def create_durable_tool(
     async def status_tool(instance_id: str) -> dict[str, Any]:
         """Check workflow status."""
         try:
-            instance = await server._edda_app.storage.get_instance(instance_id)
+            instance = await server.storage.get_instance(instance_id)
             if instance is None:
                 return {
                     "content": [
@@ -142,7 +141,7 @@ def create_durable_tool(
     async def result_tool(instance_id: str) -> dict[str, Any]:
         """Get workflow result (if completed)."""
         try:
-            instance = await server._edda_app.storage.get_instance(instance_id)
+            instance = await server.storage.get_instance(instance_id)
             if instance is None:
                 return {
                     "content": [

edda/integrations/mcp/server.py

@@ -3,11 +3,14 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import Any, cast
+from typing import TYPE_CHECKING, Any, cast
 
 from edda.app import EddaApp
 from edda.workflow import Workflow
 
+if TYPE_CHECKING:
+    from edda.storage.protocol import StorageProtocol
+
 try:
     from mcp.server.fastmcp import FastMCP  # type: ignore[import-not-found]
 except ImportError as e:
@@ -45,7 +48,13 @@ class EddaMCPServer:
 
         # Deploy with uvicorn (HTTP transport)
         if __name__ == "__main__":
+            import asyncio
             import uvicorn
+
+            async def startup():
+                await server.initialize()
+
+            asyncio.run(startup())
             uvicorn.run(server.asgi_app(), host="0.0.0.0", port=8000)
 
         # Or deploy with stdio (for MCP clients, e.g., Claude Desktop)
@@ -97,6 +106,22 @@ class EddaMCPServer:
         # Registry of durable tools (workflow_name -> Workflow instance)
         self._workflows: dict[str, Workflow] = {}
 
+    @property
+    def storage(self) -> StorageProtocol:
+        """
+        Access workflow storage for querying instances and history.
+
+        Returns:
+            StorageProtocol: Storage backend for workflow state
+
+        Example:
+            ```python
+            instance = await server.storage.get_instance(instance_id)
+            history = await server.storage.get_history(instance_id)
+            ```
+        """
+        return self._edda_app.storage
+
     def durable_tool(
         self,
         func: Callable[..., Any] | None = None,
@@ -135,6 +160,59 @@ class EddaMCPServer:
             return decorator
         return decorator(func)
 
+    def prompt(
+        self,
+        func: Callable[..., Any] | None = None,
+        *,
+        description: str = "",
+    ) -> Callable[..., Any]:
+        """
+                Decorator to define a prompt template.
+
+                Prompts can access workflow state to generate dynamic, context-aware
+                prompts for AI clients (Claude Desktop, etc.).
+
+                Args:
+                    func: Prompt function (async or sync)
+                    description: Prompt description for MCP clients
+
+                Returns:
+                    Decorated function
+
+                Example:
+                    ```python
+                    from fastmcp.prompts.prompt import PromptMessage, TextContent
+
+                    @server.prompt(description="Analyze workflow results")
+                    async def analyze_workflow(instance_id: str) -> PromptMessage:
+                        '''Generate a prompt to analyze a specific workflow execution.'''
+                        instance = await server.storage.get_instance(instance_id)
+                        history = await server.storage.get_history(instance_id)
+
+                        text = f'''Analyze this workflow:
+
+        Instance ID: {instance_id}
+        Status: {instance['status']}
+        Activities: {len(history)}
+
+        Please identify any issues or optimization opportunities.'''
+
+                        return PromptMessage(
+                            role="user",
+                            content=TextContent(type="text", text=text)
+                        )
+                    ```
+        """
+
+        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))
+
+        if func is None:
+            return decorator
+        return decorator(func)
+
     def asgi_app(self) -> Callable[..., Any]:
         """
         Create ASGI application with MCP + CloudEvents support.
@@ -221,11 +299,9 @@ class EddaMCPServer:
         """
         Initialize the EddaApp (setup replay engine, storage, etc.).
 
-        This method must be called before running the server in stdio mode.
-        For HTTP mode (asgi_app()), initialization happens automatically
-        when the ASGI app is deployed.
+        This method must be called before running the server in either stdio or HTTP mode.
 
-        Example:
+        Example (stdio mode):
             ```python
             async def main():
                 await server.initialize()
@@ -235,9 +311,85 @@ class EddaMCPServer:
                 import asyncio
                 asyncio.run(main())
             ```
+
+        Example (HTTP mode):
+            ```python
+            import asyncio
+            import uvicorn
+
+            async def startup():
+                await server.initialize()
+
+            asyncio.run(startup())
+            uvicorn.run(server.asgi_app(), host="0.0.0.0", port=8000)
+            ```
         """
         await self._edda_app.initialize()
 
+    async def shutdown(self) -> None:
+        """
+        Shutdown the server and cleanup resources.
+
+        Stops background tasks (auto-resume, timer checks, event timeouts),
+        closes storage connections, and performs graceful shutdown.
+
+        This method should be called when the server is shutting down.
+
+        Example (stdio mode):
+            ```python
+            import signal
+            import asyncio
+
+            async def main():
+                server = EddaMCPServer(...)
+                await server.initialize()
+
+                # Setup signal handlers for graceful shutdown
+                loop = asyncio.get_running_loop()
+                shutdown_event = asyncio.Event()
+
+                def signal_handler():
+                    shutdown_event.set()
+
+                for sig in (signal.SIGTERM, signal.SIGINT):
+                    loop.add_signal_handler(sig, signal_handler)
+
+                # Run server
+                try:
+                    await server.run_stdio()
+                finally:
+                    await server.shutdown()
+
+            if __name__ == "__main__":
+                asyncio.run(main())
+            ```
+
+        Example (HTTP mode with uvicorn):
+            ```python
+            import asyncio
+            import uvicorn
+
+            async def startup():
+                await server.initialize()
+
+            async def shutdown_handler():
+                await server.shutdown()
+
+            # Use uvicorn lifecycle events
+            config = uvicorn.Config(
+                server.asgi_app(),
+                host="0.0.0.0",
+                port=8000,
+            )
+            server_instance = uvicorn.Server(config)
+
+            # Uvicorn handles SIGTERM/SIGINT automatically
+            await server_instance.serve()
+            await shutdown_handler()
+            ```
+        """
+        await self._edda_app.shutdown()
+
     async def run_stdio(self) -> None:
         """
         Run MCP server with stdio transport (for MCP clients, e.g., Claude Desktop).

{edda_framework-0.3.1.dist-info → edda_framework-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edda-framework
-Version: 0.3.1
+Version: 0.4.0
 Summary: Lightweight Durable Execution Framework
 Project-URL: Homepage, https://github.com/i2y/edda
 Project-URL: Documentation, https://github.com/i2y/edda#readme
@@ -730,6 +730,32 @@ Each `@durable_tool` automatically generates **three MCP tools**:
 
 This enables AI assistants to work with workflows that take minutes, hours, or even days to complete.
 
+### MCP Prompts
+
+Define reusable prompt templates that can access workflow state:
+
+```python
+from mcp.server.fastmcp.prompts.base import UserMessage
+from mcp.types import TextContent
+
+@server.prompt(description="Analyze a workflow execution")
+async def analyze_workflow(instance_id: str) -> UserMessage:
+    """Generate analysis prompt for a specific workflow."""
+    instance = await server.storage.get_instance(instance_id)
+    history = await server.storage.get_history(instance_id)
+
+    text = f"""Analyze this workflow:
+**Status**: {instance['status']}
+**Activities**: {len(history)}
+**Result**: {instance.get('output_data')}
+
+Please provide insights and optimization suggestions."""
+
+    return UserMessage(content=TextContent(type="text", text=text))
+```
+
+AI clients can use these prompts to generate context-aware analysis of your workflows.
+
 **For detailed documentation**, see [MCP Integration Guide](docs/integrations/mcp.md).
 
 ## Observability Hooks

{edda_framework-0.3.1.dist-info → edda_framework-0.4.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=MIHDrcP_OelxOXISkX6a561Gl3DcVNT9yRakd4O4COo,6333
-edda/integrations/mcp/server.py,sha256=sSemdl7uR133YgZn34uUWzjJUqnPi13HauzXOrf8Kq8,9175
+edda/integrations/mcp/decorators.py,sha256=UTBb-Un2JK938pDZmANOvfsdKOMI2AF9yGtfSuy8VrE,6284
+edda/integrations/mcp/server.py,sha256=pzCG46Zko9hHmQ3REbo1w3A23SjrGFLiZupwSkIPhOA,13942
 edda/outbox/__init__.py,sha256=azXG1rtheJEjOyoWmMsBeR2jp8Bz02R3wDEd5tQnaWA,424
 edda/outbox/relayer.py,sha256=2tnN1aOQ8pKWfwEGIlYwYLLwyOKXBjZ4XZsIr1HjgK4,9454
 edda/outbox/transactional.py,sha256=LFfUjunqRlGibaINi-efGXFFivWGO7v3mhqrqyGW6Nw,3808
@@ -33,8 +33,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.3.1.dist-info/METADATA,sha256=uOiXJuq8Xy4fgfyblF3FwbJpo-cJrXVWgHhoIjdIi9s,29421
-edda_framework-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-edda_framework-0.3.1.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
-edda_framework-0.3.1.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
-edda_framework-0.3.1.dist-info/RECORD,,
+edda_framework-0.4.0.dist-info/METADATA,sha256=YEsevYgVMtBEBJlAhQL1lALOOiNrejsC9Z6QpyZsFRg,30272
+edda_framework-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+edda_framework-0.4.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
+edda_framework-0.4.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
+edda_framework-0.4.0.dist-info/RECORD,,