griptape-nodes 0.51.1__py3-none-any.whl → 0.52.0__py3-none-any.whl

griptape_nodes/app/app.py

@@ -1,21 +1,16 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
+import contextvars
 import json
 import logging
 import os
-import signal
 import sys
-import threading
 from pathlib import Path
-from queue import Queue
-from typing import Any, cast
+from typing import Any
 from urllib.parse import urljoin
 
-from griptape.events import (
-    EventBus,
-    EventListener,
-)
 from rich.align import Align
 from rich.console import Console
 from rich.logging import RichHandler
@@ -23,7 +18,6 @@ from rich.panel import Panel
 from websockets.asyncio.client import connect
 from websockets.exceptions import ConnectionClosed, WebSocketException
 
-from griptape_nodes.mcp_server.server import main as mcp_server
 from griptape_nodes.retained_mode.events import app_events, execution_events
 
 # This import is necessary to register all events, even if not technically used
@@ -36,29 +30,31 @@ from griptape_nodes.retained_mode.events.base_events import (
     ExecutionGriptapeNodeEvent,
     GriptapeNodeEvent,
     ProgressEvent,
-    RequestPayload,
     SkipTheLineMixin,
     deserialize_event,
 )
 from griptape_nodes.retained_mode.events.logger_events import LogHandlerEvent
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
-from .api import start_api
-
-# This is a global event queue that will be used to pass events between threads
-event_queue = Queue()
-
-# Global WebSocket connection for sending events
-ws_connection_for_sending = None
-event_loop = None
+# Context variable for WebSocket connection - avoids global state
+ws_connection_context: contextvars.ContextVar[Any | None] = contextvars.ContextVar("ws_connection", default=None)
 
 # Event to signal when WebSocket connection is ready
-ws_ready_event = threading.Event()
+ws_ready_event = asyncio.Event()
 
 
 # Whether to enable the static server
 STATIC_SERVER_ENABLED = os.getenv("STATIC_SERVER_ENABLED", "true").lower() == "true"
 
+# Semaphore to limit concurrent requests
+REQUEST_SEMAPHORE = asyncio.Semaphore(100)
+
+
+# Important to bootstrap singleton here so that we don't
+# get any weird circular import issues from the EventLogHandler
+# initializing it from a log during it's own initialization.
+griptape_nodes: GriptapeNodes = GriptapeNodes()
+
 
 class EventLogHandler(logging.Handler):
     """Custom logging handler that emits log messages as AppEvents.
@@ -67,11 +63,10 @@ class EventLogHandler(logging.Handler):
     """
 
     def emit(self, record: logging.LogRecord) -> None:
-        event_queue.put(
-            AppEvent(
-                payload=LogHandlerEvent(message=record.getMessage(), levelname=record.levelname, created=record.created)
-            )
+        log_event = AppEvent(
+            payload=LogHandlerEvent(message=record.getMessage(), levelname=record.levelname, created=record.created)
         )
+        griptape_nodes.EventManager().put_event(log_event)
 
 
 # Logger for this module. Important that this is not the same as the griptape_nodes logger or else we'll have infinite log events.
@@ -87,26 +82,79 @@ console = Console()
 
 
 def start_app() -> None:
-    """Main entry point for the Griptape Nodes app.
+    """Legacy sync entry point - runs async app."""
+    try:
+        asyncio.run(astart_app())
+    except KeyboardInterrupt:
+        logger.info("Application stopped by user")
+    except Exception as e:
+        logger.error("Application error: %s", e)
 
-    Starts the event loop and listens for events from the Nodes API.
-    """
-    _init_event_listeners()
-    # Listen for any signals to exit the app
-    for sig in (signal.SIGINT, signal.SIGTERM):
-        signal.signal(sig, lambda *_: sys.exit(0))
 
+async def astart_app() -> None:
+    """New async app entry point."""
     api_key = _ensure_api_key()
-    threading.Thread(target=mcp_server, args=(api_key,), daemon=True).start()
-    threading.Thread(target=_listen_for_api_events, args=(api_key,), daemon=True).start()
-    if STATIC_SERVER_ENABLED:
-        static_dir = _build_static_dir()
-        threading.Thread(target=start_api, args=(static_dir, event_queue), daemon=True).start()
-    _process_event_queue()
+
+    griptape_nodes.EventManager().initialize_queue()
+
+    # Create shared context for all tasks to inherit WebSocket connection
+    shared_context = contextvars.copy_context()
+
+    try:
+        # We need to run the servers in a separate thread otherwise
+        # blocking requests to them in the main thread would deadlock the event loop.
+        server_tasks = []
+
+        # Start MCP server in thread
+        server_tasks.append(asyncio.to_thread(_run_mcp_server_sync, api_key))
+
+        # Start static server in thread if enabled
+        if STATIC_SERVER_ENABLED:
+            static_dir = _build_static_dir()
+            server_tasks.append(asyncio.to_thread(_run_static_server_sync, static_dir))
+
+        # Run main event loop tasks
+        main_tasks = [
+            _listen_for_api_requests(api_key),
+            _process_event_queue(),
+        ]
+
+        # Combine server tasks and main tasks
+        all_tasks = server_tasks + main_tasks
+
+        async with asyncio.TaskGroup() as tg:
+            for task in all_tasks:
+                # Context is supposed to be copied automatically, but it isn't working for some reason so we do it manually here
+                tg.create_task(task, context=shared_context)
+    except Exception as e:
+        logger.error("Application startup failed: %s", e)
+        raise
+
+
+def _run_mcp_server_sync(api_key: str) -> None:
+    """Run MCP server in a separate thread."""
+    try:
+        from griptape_nodes.mcp_server.server import main_sync
+
+        main_sync(api_key)
+    except Exception as e:
+        logger.error("MCP server thread error: %s", e)
+        raise
+
+
+def _run_static_server_sync(static_dir: Path) -> None:
+    """Run static server in a separate thread."""
+    try:
+        from .api import start_api
+
+        start_api(static_dir)
+    except Exception as e:
+        logger.error("Static server thread error: %s", e)
+        raise
 
 
 def _ensure_api_key() -> str:
-    secrets_manager = GriptapeNodes.SecretsManager()
+    secrets_manager = griptape_nodes.SecretsManager()
     api_key = secrets_manager.get_secret("GT_CLOUD_API_KEY")
     if api_key is None:
         message = Panel(
@@ -127,79 +175,145 @@ def _ensure_api_key() -> str:
 
 def _build_static_dir() -> Path:
     """Build the static directory path based on the workspace configuration."""
-    config_manager = GriptapeNodes.ConfigManager()
+    config_manager = griptape_nodes.ConfigManager()
     return Path(config_manager.workspace_path) / config_manager.merged_config["static_files_directory"]
 
 
-def _init_event_listeners() -> None:
-    """Set up the Griptape EventBus EventListeners."""
-    EventBus.add_event_listener(
-        event_listener=EventListener(on_event=__process_node_event, event_types=[GriptapeNodeEvent])
-    )
+async def _listen_for_api_requests(api_key: str) -> None:
+    """Listen for events and add to async queue."""
+    logger.info("Listening for events from Nodes API via async WebSocket")
 
-    EventBus.add_event_listener(
-        event_listener=EventListener(
-            on_event=__process_execution_node_event,
-            event_types=[ExecutionGriptapeNodeEvent],
-        )
-    )
+    connection_stream = _create_websocket_connection(api_key)
+    initialized = False
 
-    EventBus.add_event_listener(
-        event_listener=EventListener(
-            on_event=__process_progress_event,
-            event_types=[ProgressEvent],
-        )
-    )
+    try:
+        async for ws_connection in connection_stream:
+            await _handle_websocket_connection(ws_connection, initialized=initialized)
+            initialized = True
+
+    except asyncio.CancelledError:
+        # Clean shutdown when task is cancelled
+        logger.info("WebSocket listener shutdown complete")
+        raise
+    except Exception as e:
+        logger.error("Fatal error in WebSocket listener: %s", e)
+        raise
+    finally:
+        await _cleanup_websocket_connection()
 
-    EventBus.add_event_listener(
-        event_listener=EventListener(
-            on_event=__process_app_event,  # pyright: ignore[reportArgumentType] TODO: https://github.com/griptape-ai/griptape-nodes/issues/868
-            event_types=[AppEvent],  # pyright: ignore[reportArgumentType] TODO: https://github.com/griptape-ai/griptape-nodes/issues/868
-        )
-    )
 
+async def _handle_websocket_connection(ws_connection: Any, *, initialized: bool) -> None:
+    """Handle a single WebSocket connection."""
+    try:
+        ws_connection_context.set(ws_connection)
+        ws_ready_event.set()
 
-async def _alisten_for_api_requests(api_key: str) -> None:
-    """Listen for events from the Nodes API and process them asynchronously."""
-    global ws_connection_for_sending, event_loop  # noqa: PLW0603
-    event_loop = asyncio.get_running_loop()  # Store the event loop reference
-    logger.info("Listening for events from Nodes API via async WebSocket")
+        if not initialized:
+            await griptape_nodes.EventManager().aput_event(AppEvent(payload=app_events.AppInitializationComplete()))
 
-    # Auto reconnect https://websockets.readthedocs.io/en/stable/reference/asyncio/client.html#opening-a-connection
-    connection_stream = _create_websocket_connection(api_key)
-    initialized = False
-    async for ws_connection in connection_stream:
-        try:
-            ws_connection_for_sending = ws_connection  # Store for sending events
-            ws_ready_event.set()  # Signal that WebSocket is ready for sending
+        await griptape_nodes.EventManager().aput_event(AppEvent(payload=app_events.AppConnectionEstablished()))
 
-            if not initialized:
-                event_queue.put(AppEvent(payload=app_events.AppInitializationComplete()))
-                initialized = True
+        async for message in ws_connection:
+            try:
+                data = json.loads(message)
+                await _process_api_event(data)
+            except Exception:
+                logger.exception("Error processing event, skipping.")
 
-            event_queue.put(AppEvent(payload=app_events.AppConnectionEstablished()))
+    except ConnectionClosed:
+        logger.info("WebSocket connection closed, will retry")
+    except Exception as e:
+        logger.error("Error in WebSocket connection. Retrying in 2 seconds... %s", e)
+        await asyncio.sleep(2.0)
+    finally:
+        ws_connection_context.set(None)
+        ws_ready_event.clear()
 
-            async for message in ws_connection:
-                try:
-                    data = json.loads(message)
 
-                    _process_api_event(data, event_queue)
-                except Exception:
-                    logger.exception("Error processing event, skipping.")
-        except ConnectionClosed:
-            continue
-        except Exception as e:
-            logger.error("Error while listening for events. Retrying in 2 seconds... %s", e)
-            await asyncio.sleep(2)
+async def _cleanup_websocket_connection() -> None:
+    """Clean up WebSocket connection on shutdown."""
+    ws_connection = ws_connection_context.get()
+    if ws_connection:
+        with contextlib.suppress(Exception):
+            await ws_connection.close()
+    logger.info("WebSocket listener shutdown complete")
 
 
-def _listen_for_api_events(api_key: str) -> None:
-    """Run the async WebSocket listener in an event loop."""
-    asyncio.run(_alisten_for_api_requests(api_key))
+async def _process_event_queue() -> None:
+    """Process events concurrently - all events can run simultaneously."""
+    # Wait for WebSocket connection (convert to async)
+    await _await_websocket_ready()
+    background_tasks = set()
 
+    def _handle_task_result(task: asyncio.Task) -> None:
+        background_tasks.discard(task)
+        if task.exception() and not task.cancelled():
+            logger.exception("Background task failed", exc_info=task.exception())
 
-def __process_node_event(event: GriptapeNodeEvent) -> None:
-    """Process GriptapeNodeEvents and send them to the API."""
+    try:
+        event_queue = griptape_nodes.EventManager().event_queue
+        while True:
+            event = await event_queue.get()
+
+            async with REQUEST_SEMAPHORE:
+                if isinstance(event, EventRequest):
+                    task = asyncio.create_task(_process_event_request(event))
+                elif isinstance(event, AppEvent):
+                    task = asyncio.create_task(_process_app_event(event))
+                elif isinstance(event, GriptapeNodeEvent):
+                    task = asyncio.create_task(_process_node_event(event))
+                elif isinstance(event, ExecutionGriptapeNodeEvent):
+                    task = asyncio.create_task(_process_execution_node_event(event))
+                elif isinstance(event, ProgressEvent):
+                    task = asyncio.create_task(_process_progress_event(event))
+                else:
+                    logger.warning("Unknown event type: %s", type(event))
+                    event_queue.task_done()
+                    continue
+
+            background_tasks.add(task)
+            task.add_done_callback(_handle_task_result)
+            event_queue.task_done()
+    except asyncio.CancelledError:
+        logger.info("Event queue processor shutdown complete")
+        raise
+
+
+async def _process_event_request(event: EventRequest) -> None:
+    """Handle request and emit success/failure events based on result."""
+    result_event = await griptape_nodes.EventManager().ahandle_request(
+        event.request,
+        result_context={"response_topic": event.response_topic, "request_id": event.request_id},
+    )
+
+    if result_event.result.succeeded():
+        dest_socket = "success_result"
+    else:
+        dest_socket = "failure_result"
+
+    await __emit_message(dest_socket, result_event.json(), topic=result_event.response_topic)
+
+
+async def _await_websocket_ready() -> None:
+    """Wait for WebSocket connection to be ready using event coordination."""
+    websocket_timeout = 15
+    try:
+        await asyncio.wait_for(ws_ready_event.wait(), timeout=websocket_timeout)
+    except TimeoutError:
+        console.print("[red]WebSocket connection timeout[/red]")
+        raise
+
+
+async def _process_app_event(event: AppEvent) -> None:
+    """Process AppEvents and send them to the API (async version)."""
+    # Let Griptape Nodes broadcast it.
+    await griptape_nodes.broadcast_app_event(event.payload)
+
+    await __emit_message("app_event", event.json())
+
+
+async def _process_node_event(event: GriptapeNodeEvent) -> None:
+    """Process GriptapeNodeEvents and send them to the API (async version)."""
     # Emit the result back to the GUI
     result_event = event.wrapped_event
     if isinstance(result_event, EventResultSuccess):
@@ -210,32 +324,16 @@ def __process_node_event(event: GriptapeNodeEvent) -> None:
         msg = f"Unknown/unsupported result event type encountered: '{type(result_event)}'."
         raise TypeError(msg) from None
 
-    __schedule_async_task(__emit_message(dest_socket, result_event.json(), topic=result_event.response_topic))
+    await __emit_message(dest_socket, result_event.json(), topic=result_event.response_topic)
 
 
-def __process_execution_node_event(event: ExecutionGriptapeNodeEvent) -> None:
-    """Process ExecutionGriptapeNodeEvents and send them to the API."""
-    result_event = event.wrapped_event
-    if type(result_event.payload).__name__ == "NodeStartProcessEvent":
-        GriptapeNodes.EventManager().current_active_node = result_event.payload.node_name
-
-    if type(result_event.payload).__name__ == "ResumeNodeProcessingEvent":
-        node_name = result_event.payload.node_name
-        logger.info("Resuming Node '%s'", node_name)
-        flow_name = GriptapeNodes.NodeManager().get_node_parent_flow_by_name(node_name)
-        request = EventRequest(request=execution_events.SingleExecutionStepRequest(flow_name=flow_name))
-        event_queue.put(request)
-
-    if type(result_event.payload).__name__ == "NodeFinishProcessEvent":
-        if result_event.payload.node_name != GriptapeNodes.EventManager().current_active_node:
-            msg = "Node start and finish do not match."
-            raise KeyError(msg) from None
-        GriptapeNodes.EventManager().current_active_node = None
-    __schedule_async_task(__emit_message("execution_event", result_event.json()))
-
-
-def __process_progress_event(gt_event: ProgressEvent) -> None:
-    """Process Griptape framework events and send them to the API."""
+async def _process_execution_node_event(event: ExecutionGriptapeNodeEvent) -> None:
+    """Process ExecutionGriptapeNodeEvents and send them to the API (async version)."""
+    await __emit_message("execution_event", event.wrapped_event.json())
+
+
+async def _process_progress_event(gt_event: ProgressEvent) -> None:
+    """Process Griptape framework events and send them to the API (async version)."""
     node_name = gt_event.node_name
     if node_name:
         value = gt_event.value
@@ -243,42 +341,7 @@ def __process_progress_event(gt_event: ProgressEvent) -> None:
             node_name=node_name, parameter_name=gt_event.parameter_name, type=type(gt_event).__name__, value=value
         )
         event_to_emit = ExecutionEvent(payload=payload)
-        __schedule_async_task(__emit_message("execution_event", event_to_emit.json()))
-
-
-def __process_app_event(event: AppEvent) -> None:
-    """Process AppEvents and send them to the API."""
-    # Let Griptape Nodes broadcast it.
-    GriptapeNodes.broadcast_app_event(event.payload)
-
-    __schedule_async_task(__emit_message("app_event", event.json()))
-
-
-def _process_event_queue() -> None:
-    """Listen for events in the event queue and process them.
-
-    Event queue will be populated by background threads listening for events from the Nodes API.
-    """
-    # Wait for WebSocket connection to be established before processing events
-    timed_out = ws_ready_event.wait(timeout=15)
-    if not timed_out:
-        console.print(
-            "[red] The connection to the websocket timed out. Please check your internet connection or the status of Griptape Nodes API.[/red]"
-        )
-        sys.exit(1)
-    while True:
-        event = event_queue.get(block=True)
-        if isinstance(event, EventRequest):
-            request_payload = event.request
-            GriptapeNodes.handle_request(
-                request_payload, response_topic=event.response_topic, request_id=event.request_id
-            )
-        elif isinstance(event, AppEvent):
-            __process_app_event(event)
-        else:
-            logger.warning("Unknown event type encountered: '%s'.", type(event))
-
-        event_queue.task_done()
+        await __emit_message("execution_event", event_to_emit.json())
 
 
 def _create_websocket_connection(api_key: str) -> Any:
@@ -296,29 +359,29 @@ def _create_websocket_connection(api_key: str) -> Any:
 
 async def __emit_message(event_type: str, payload: str, topic: str | None = None) -> None:
     """Send a message via WebSocket asynchronously."""
-    global ws_connection_for_sending  # noqa: PLW0602
-    if ws_connection_for_sending is None:
+    ws_connection = ws_connection_context.get()
+    if ws_connection is None:
         logger.warning("WebSocket connection not available for sending message")
         return
 
     try:
         # Determine topic based on session_id and engine_id in the payload
         if topic is None:
-            topic = _determine_response_topic()
+            topic = determine_response_topic()
 
         body = {"type": event_type, "payload": json.loads(payload), "topic": topic}
 
-        await ws_connection_for_sending.send(json.dumps(body))
+        await ws_connection.send(json.dumps(body))
     except WebSocketException as e:
         logger.error("Error sending event to Nodes API: %s", e)
     except Exception as e:
         logger.error("Unexpected error while sending event to Nodes API: %s", e)
 
 
-def _determine_response_topic() -> str | None:
+def determine_response_topic() -> str | None:
     """Determine the response topic based on session_id and engine_id in the payload."""
-    engine_id = GriptapeNodes.get_engine_id()
-    session_id = GriptapeNodes.get_session_id()
+    engine_id = griptape_nodes.get_engine_id()
+    session_id = griptape_nodes.get_session_id()
 
     # Normal topic determination logic
     # Check for session_id first (highest priority)
@@ -333,10 +396,10 @@ def _determine_response_topic() -> str | None:
     return "response"
 
 
-def _determine_request_topic() -> str | None:
+def determine_request_topic() -> str | None:
     """Determine the request topic based on session_id and engine_id in the payload."""
-    engine_id = GriptapeNodes.get_engine_id()
-    session_id = GriptapeNodes.get_session_id()
+    engine_id = griptape_nodes.get_engine_id()
+    session_id = griptape_nodes.get_session_id()
 
     # Normal topic determination logic
     # Check for session_id first (highest priority)
@@ -351,25 +414,16 @@ def _determine_request_topic() -> str | None:
     return "request"
 
 
-def subscribe_to_topic(topic: str) -> None:
-    """Subscribe to a specific topic in the message bus."""
-    __schedule_async_task(_asubscribe_to_topic(topic))
-
-
-def unsubscribe_from_topic(topic: str) -> None:
-    """Unsubscribe from a specific topic in the message bus."""
-    __schedule_async_task(_aunsubscribe_from_topic(topic))
-
-
-async def _asubscribe_to_topic(topic: str) -> None:
+async def subscribe_to_topic(topic: str) -> None:
     """Subscribe to a specific topic in the message bus."""
-    if ws_connection_for_sending is None:
+    ws_connection = ws_connection_context.get()
+    if ws_connection is None:
         logger.warning("WebSocket connection not available for subscribing to topic")
         return
 
     try:
         body = {"type": "subscribe", "topic": topic, "payload": {}}
-        await ws_connection_for_sending.send(json.dumps(body))
+        await ws_connection.send(json.dumps(body))
         logger.info("Subscribed to topic: %s", topic)
     except WebSocketException as e:
         logger.error("Error subscribing to topic %s: %s", topic, e)
@@ -377,15 +431,16 @@ async def _asubscribe_to_topic(topic: str) -> None:
         logger.error("Unexpected error while subscribing to topic %s: %s", topic, e)
 
 
-async def _aunsubscribe_from_topic(topic: str) -> None:
+async def unsubscribe_from_topic(topic: str) -> None:
     """Unsubscribe from a specific topic in the message bus."""
-    if ws_connection_for_sending is None:
+    ws_connection = ws_connection_context.get()
+    if ws_connection is None:
         logger.warning("WebSocket connection not available for unsubscribing from topic")
         return
 
     try:
         body = {"type": "unsubscribe", "topic": topic, "payload": {}}
-        await ws_connection_for_sending.send(json.dumps(body))
+        await ws_connection.send(json.dumps(body))
         logger.info("Unsubscribed from topic: %s", topic)
     except WebSocketException as e:
         logger.error("Error unsubscribing from topic %s: %s", topic, e)
@@ -393,16 +448,8 @@ async def _aunsubscribe_from_topic(topic: str) -> None:
         logger.error("Unexpected error while unsubscribing from topic %s: %s", topic, e)
 
 
-def __schedule_async_task(coro: Any) -> None:
-    """Schedule an async coroutine to run in the event loop from a sync context."""
-    if event_loop and event_loop.is_running():
-        asyncio.run_coroutine_threadsafe(coro, event_loop)
-    else:
-        logger.warning("Event loop not available for scheduling async task")
-
-
-def _process_api_event(event: dict, event_queue: Queue) -> None:
-    """Process API events and send them to the event queue."""
+async def _process_api_event(event: dict) -> None:
+    """Process API events and add to async queue."""
     payload = event.get("payload", {})
 
     try:
@@ -423,43 +470,18 @@ def _process_api_event(event: dict, event_queue: Queue) -> None:
     # Now attempt to convert it into an EventRequest.
     try:
         request_event = deserialize_event(json_data=payload)
-        if not isinstance(request_event, EventRequest):
-            msg = f"Deserialized event is not an EventRequest: {type(request_event)}"
-            raise TypeError(msg)  # noqa: TRY301
     except Exception as e:
         msg = f"Unable to convert request JSON into a valid EventRequest object. Error Message: '{e}'"
         raise RuntimeError(msg) from None
 
+    if not isinstance(request_event, EventRequest):
+        msg = f"Deserialized event is not an EventRequest: {type(request_event)}"
+        raise TypeError(msg)
+
     # Check if the event implements SkipTheLineMixin for priority processing
     if isinstance(request_event.request, SkipTheLineMixin):
         # Handle the event immediately without queuing
-        # The request is guaranteed to be a RequestPayload since it passed earlier validation
-        result_payload = GriptapeNodes.handle_request(
-            cast("RequestPayload", request_event.request),
-            response_topic=request_event.response_topic,
-            request_id=request_event.request_id,
-        )
-
-        # Create the result event and emit response immediately
-        if result_payload.succeeded():
-            result_event = EventResultSuccess(
-                request=cast("RequestPayload", request_event.request),
-                request_id=request_event.request_id,
-                result=result_payload,
-                response_topic=request_event.response_topic,
-            )
-            dest_socket = "success_result"
-        else:
-            result_event = EventResultFailure(
-                request=cast("RequestPayload", request_event.request),
-                request_id=request_event.request_id,
-                result=result_payload,
-                response_topic=request_event.response_topic,
-            )
-            dest_socket = "failure_result"
-
-        # Emit the response immediately
-        __schedule_async_task(__emit_message(dest_socket, result_event.json(), topic=result_event.response_topic))
+        await _process_event_request(request_event)
     else:
-        # Add the event to the queue for normal processing
-        event_queue.put(request_event)
+        # Add the event to the async queue for normal processing
+        await griptape_nodes.EventManager().aput_event(request_event)

griptape_nodes/app/watch.py

@@ -31,7 +31,7 @@ class ReloadHandler(PatternMatchingEventHandler):
 
     def start_process(self) -> None:
         if self.process:
-            self.process.terminate()
+            self._terminate_process(self.process)
         uv_path = find_uv_bin()
         self.process = subprocess.Popen(  # noqa: S603
             [uv_path, "run", "gtn"],
@@ -39,6 +39,21 @@ class ReloadHandler(PatternMatchingEventHandler):
             stderr=sys.stderr,
         )
 
+    def _terminate_process(self, process: subprocess.Popen) -> None:
+        """Gracefully terminate a process with timeout."""
+        if process.poll() is not None:
+            return  # Process already terminated
+
+        # First try graceful termination
+        process.terminate()
+        try:
+            # Wait up to 5 seconds for graceful shutdown
+            process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            # Force kill if it doesn't shut down gracefully
+            process.kill()
+            process.wait()
+
     def on_modified(self, event: Any) -> None:
         """Called on any file event in the watched directory (create, modify, delete, move)."""
         # Don't reload if the event is on a directory
@@ -65,7 +80,7 @@ if __name__ == "__main__":
             time.sleep(1)
     except KeyboardInterrupt:
         if event_handler.process:
-            event_handler.process.terminate()
+            event_handler._terminate_process(event_handler.process)
     finally:
         observer.stop()
         observer.join()