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

griptape_nodes/__main__.py

@@ -0,0 +1,6 @@
+"""Main entry point for the Griptape Nodes CLI when run as a module."""
+
+from griptape_nodes import main
+
+if __name__ == "__main__":
+    main()

griptape_nodes/app/api.py

@@ -141,17 +141,6 @@ async def _delete_static_file(file_path: str, static_directory: Annotated[Path,
         return {"message": f"File {file_path} deleted successfully"}
 
 
-@app.post("/engines/request")
-async def _create_event(request: Request) -> None:
-    """Create event using centralized event utilities."""
-    from .app import _process_api_event
-
-    body = await request.json()
-
-    # Use centralized event processing
-    await _process_api_event(body)
-
-
 def _setup_app(static_directory: Path) -> None:
     """Setup FastAPI app with middleware and static files."""
     global static_dir  # noqa: PLW0603
@@ -179,7 +168,7 @@ def _setup_app(static_directory: Path) -> None:
     )
 
 
-def start_api(static_directory: Path) -> None:
+def start_static_server(static_directory: Path) -> None:
     """Run uvicorn server synchronously using uvicorn.run."""
     # Setup the FastAPI app
     _setup_app(static_directory)

griptape_nodes/app/app.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
 import asyncio
-import contextlib
-import contextvars
 import json
 import logging
 import os
 import sys
+import threading
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 from urllib.parse import urljoin
@@ -16,8 +16,10 @@ from rich.console import Console
 from rich.logging import RichHandler
 from rich.panel import Panel
 from websockets.asyncio.client import connect
-from websockets.exceptions import ConnectionClosed, WebSocketException
+from websockets.exceptions import ConnectionClosed, ConnectionClosedError, WebSocketException
 
+from griptape_nodes.app.api import start_static_server
+from griptape_nodes.mcp_server.server import start_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,18 +38,29 @@ from griptape_nodes.retained_mode.events.base_events import (
 from griptape_nodes.retained_mode.events.logger_events import LogHandlerEvent
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
-# 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 = asyncio.Event()
+# WebSocket thread communication message types
+@dataclass
+class WebSocketMessage:
+    """Message to send via WebSocket."""
 
+    event_type: str
+    payload: str
+    topic: str | None = None
 
-# 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)
+@dataclass
+class SubscribeCommand:
+    """Command to subscribe to a topic."""
+
+    topic: str
+
+
+@dataclass
+class UnsubscribeCommand:
+    """Command to unsubscribe from a topic."""
+
+    topic: str
 
 
 # Important to bootstrap singleton here so that we don't
@@ -55,6 +68,24 @@ REQUEST_SEMAPHORE = asyncio.Semaphore(100)
 # initializing it from a log during it's own initialization.
 griptape_nodes: GriptapeNodes = GriptapeNodes()
 
+# WebSocket outgoing queue for messages and commands.
+# Appears to be fine to create outside event loop
+# https://discuss.python.org/t/can-asyncio-queue-be-safely-created-outside-of-the-event-loop-thread/49215/8
+ws_outgoing_queue: asyncio.Queue = asyncio.Queue()
+
+# Background WebSocket event loop reference for cross-thread communication
+websocket_event_loop: asyncio.AbstractEventLoop | None = None
+
+# Threading event to signal when websocket_event_loop is ready
+websocket_event_loop_ready = threading.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)
+
 
 class EventLogHandler(logging.Handler):
     """Custom logging handler that emits log messages as AppEvents.
@@ -73,10 +104,12 @@ class EventLogHandler(logging.Handler):
 logger = logging.getLogger("griptape_nodes_app")
 
 griptape_nodes_logger = logging.getLogger("griptape_nodes")
-# When running as an app, we want to forward all log messages to the event queue so they can be sent to the GUI
-griptape_nodes_logger.addHandler(EventLogHandler())
-griptape_nodes_logger.addHandler(RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True))
-griptape_nodes_logger.setLevel(logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(message)s",
+    datefmt="[%X]",
+    handlers=[EventLogHandler(), RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True)],
+)
 
 console = Console()
 
@@ -95,62 +128,89 @@ async def astart_app() -> None:
     """New async app entry point."""
     api_key = _ensure_api_key()
 
+    # Initialize event queue in main thread
     griptape_nodes.EventManager().initialize_queue()
 
-    # Create shared context for all tasks to inherit WebSocket connection
-    shared_context = contextvars.copy_context()
+    # Get main loop reference
+    main_loop = asyncio.get_running_loop()
 
     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 MCP server in daemon thread
+        threading.Thread(target=start_mcp_server, args=(api_key,), daemon=True, name="mcp-server").start()
 
-        # Start static server in thread if enabled
+        # Start static server in daemon thread if enabled
         if STATIC_SERVER_ENABLED:
             static_dir = _build_static_dir()
-            server_tasks.append(asyncio.to_thread(_run_static_server_sync, static_dir))
+            threading.Thread(target=start_static_server, args=(static_dir,), daemon=True, name="static-server").start()
 
-        # Run main event loop tasks
-        main_tasks = [
-            _listen_for_api_requests(api_key),
-            _process_event_queue(),
-        ]
+        # Start WebSocket tasks in daemon thread
+        threading.Thread(
+            target=_start_websocket_connection, args=(api_key, main_loop), daemon=True, name="websocket-tasks"
+        ).start()
 
-        # Combine server tasks and main tasks
-        all_tasks = server_tasks + main_tasks
+        # Run event processing on main thread
+        await _process_event_queue()
 
-        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."""
+def _start_websocket_connection(api_key: str, main_loop: asyncio.AbstractEventLoop) -> None:
+    """Run WebSocket tasks in a separate thread with its own async loop."""
+    global websocket_event_loop  # noqa: PLW0603
     try:
-        from griptape_nodes.mcp_server.server import main_sync
+        # Create a new event loop for this thread
+        loop = asyncio.new_event_loop()
+        websocket_event_loop = loop
+        asyncio.set_event_loop(loop)
+
+        # Signal that websocket_event_loop is ready
+        websocket_event_loop_ready.set()
 
-        main_sync(api_key)
+        # Run the async WebSocket tasks
+        loop.run_until_complete(_run_websocket_tasks(api_key, main_loop))
     except Exception as e:
-        logger.error("MCP server thread error: %s", e)
+        logger.error("WebSocket thread error: %s", e)
         raise
+    finally:
+        websocket_event_loop = None
+        websocket_event_loop_ready.clear()
 
 
-def _run_static_server_sync(static_dir: Path) -> None:
-    """Run static server in a separate thread."""
-    try:
-        from .api import start_api
+async def _run_websocket_tasks(api_key: str, main_loop: asyncio.AbstractEventLoop) -> None:
+    """Run WebSocket tasks - async version."""
+    # Create WebSocket connection for this thread
+    connection_stream = _create_websocket_connection(api_key)
 
-        start_api(static_dir)
-    except Exception as e:
-        logger.error("Static server thread error: %s", e)
-        raise
+    # Track if this is the first connection
+    initialized = False
+
+    async for ws_connection in connection_stream:
+        logger.info("WebSocket connection established")
+        try:
+            # Emit initialization event only for the first connection
+            if not initialized:
+                griptape_nodes.EventManager().put_event_threadsafe(
+                    main_loop, AppEvent(payload=app_events.AppInitializationComplete())
+                )
+                initialized = True
+
+            # Emit connection established event for every connection
+            griptape_nodes.EventManager().put_event_threadsafe(
+                main_loop, AppEvent(payload=app_events.AppConnectionEstablished())
+            )
+
+            async with asyncio.TaskGroup() as tg:
+                tg.create_task(_process_incoming_messages(ws_connection, main_loop))
+                tg.create_task(_send_outgoing_messages(ws_connection))
+        except (ExceptionGroup, ConnectionClosed, ConnectionClosedError):
+            logger.info("WebSocket connection closed, reconnecting...")
+            continue
+        except Exception:
+            logger.exception("WebSocket tasks failed")
+            await asyncio.sleep(2.0)  # Wait before retry
+            continue
 
 
 def _ensure_api_key() -> str:
@@ -179,70 +239,134 @@ def _build_static_dir() -> Path:
     return Path(config_manager.workspace_path) / config_manager.merged_config["static_files_directory"]
 
 
-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")
+async def _process_incoming_messages(ws_connection: Any, main_loop: asyncio.AbstractEventLoop) -> None:
+    """Process incoming WebSocket requests from Nodes API."""
+    logger.debug("Processing incoming WebSocket requests from WebSocket connection")
 
-    connection_stream = _create_websocket_connection(api_key)
-    initialized = False
+    async for message in ws_connection:
+        try:
+            data = json.loads(message)
+            await _process_api_event(data, main_loop)
+        except Exception:
+            logger.exception("Error processing event, skipping.")
+
+
+def _create_websocket_connection(api_key: str) -> Any:
+    """Create an async WebSocket connection to the Nodes API."""
+    endpoint = urljoin(
+        os.getenv("GRIPTAPE_NODES_API_BASE_URL", "https://api.nodes.griptape.ai").replace("http", "ws"),
+        "/ws/engines/events?version=v2",
+    )
+
+    return connect(
+        endpoint,
+        additional_headers={"Authorization": f"Bearer {api_key}"},
+    )
+
+
+async def _process_api_event(event: dict, main_loop: asyncio.AbstractEventLoop) -> None:
+    """Process API events and add to async queue."""
+    payload = event.get("payload", {})
 
     try:
-        async for ws_connection in connection_stream:
-            await _handle_websocket_connection(ws_connection, initialized=initialized)
-            initialized = True
+        payload["request"]
+    except KeyError:
+        msg = "Error: 'request' was expected but not found."
+        raise RuntimeError(msg) from None
 
-    except asyncio.CancelledError:
-        # Clean shutdown when task is cancelled
-        logger.info("WebSocket listener shutdown complete")
-        raise
+    try:
+        event_type = payload["event_type"]
+        if event_type != "EventRequest":
+            msg = "Error: 'event_type' was found on request, but did not match 'EventRequest' as expected."
+            raise RuntimeError(msg) from None
+    except KeyError:
+        msg = "Error: 'event_type' not found in request."
+        raise RuntimeError(msg) from None
+
+    # Now attempt to convert it into an EventRequest.
+    try:
+        request_event = deserialize_event(json_data=payload)
     except Exception as e:
-        logger.error("Fatal error in WebSocket listener: %s", e)
-        raise
-    finally:
-        await _cleanup_websocket_connection()
+        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)
 
-async def _handle_websocket_connection(ws_connection: Any, *, initialized: bool) -> None:
-    """Handle a single WebSocket connection."""
+    # Check if the event implements SkipTheLineMixin for priority processing
+    if isinstance(request_event.request, SkipTheLineMixin):
+        # Handle the event immediately without queuing
+        await _process_event_request(request_event)
+    else:
+        # Add the event to the main thread event queue for processing
+        griptape_nodes.EventManager().put_event_threadsafe(main_loop, request_event)
+
+
+async def _send_outgoing_messages(ws_connection: Any) -> None:
+    """Send outgoing WebSocket requests from queue on background thread."""
+    logger.debug("Starting outgoing WebSocket request sender")
+
+    while True:
+        # Get message from outgoing queue
+        message = await ws_outgoing_queue.get()
+
+        try:
+            if isinstance(message, WebSocketMessage):
+                await _send_websocket_message(ws_connection, message.event_type, message.payload, message.topic)
+            elif isinstance(message, SubscribeCommand):
+                await _send_subscribe_command(ws_connection, message.topic)
+            elif isinstance(message, UnsubscribeCommand):
+                await _send_unsubscribe_command(ws_connection, message.topic)
+            else:
+                logger.warning("Unknown outgoing message type: %s", type(message))
+        except Exception as e:
+            logger.error("Error sending outgoing WebSocket request: %s", e)
+        finally:
+            ws_outgoing_queue.task_done()
+
+
+async def _send_websocket_message(ws_connection: Any, event_type: str, payload: str, topic: str | None) -> None:
+    """Send a message via WebSocket."""
     try:
-        ws_connection_context.set(ws_connection)
-        ws_ready_event.set()
-
-        if not initialized:
-            await griptape_nodes.EventManager().aput_event(AppEvent(payload=app_events.AppInitializationComplete()))
+        if topic is None:
+            topic = determine_response_topic()
 
-        await griptape_nodes.EventManager().aput_event(AppEvent(payload=app_events.AppConnectionEstablished()))
+        body = {"type": event_type, "payload": json.loads(payload), "topic": topic}
+        await ws_connection.send(json.dumps(body))
+    except WebSocketException as e:
+        logger.error("Error sending WebSocket message: %s", e)
+    except Exception as e:
+        logger.error("Unexpected error sending WebSocket message: %s", e)
 
-        async for message in ws_connection:
-            try:
-                data = json.loads(message)
-                await _process_api_event(data)
-            except Exception:
-                logger.exception("Error processing event, skipping.")
 
-    except ConnectionClosed:
-        logger.info("WebSocket connection closed, will retry")
+async def _send_subscribe_command(ws_connection: Any, topic: str) -> None:
+    """Send subscribe command via WebSocket."""
+    try:
+        body = {"type": "subscribe", "topic": topic, "payload": {}}
+        await ws_connection.send(json.dumps(body))
+        logger.debug("Subscribed to topic: %s", topic)
+    except WebSocketException as e:
+        logger.error("Error subscribing to topic %s: %s", topic, e)
     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()
+        logger.error("Unexpected error subscribing to topic %s: %s", topic, e)
 
 
-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")
+async def _send_unsubscribe_command(ws_connection: Any, topic: str) -> None:
+    """Send unsubscribe command via WebSocket."""
+    try:
+        body = {"type": "unsubscribe", "topic": topic, "payload": {}}
+        await ws_connection.send(json.dumps(body))
+        logger.debug("Unsubscribed from topic: %s", topic)
+    except WebSocketException as e:
+        logger.error("Error unsubscribing from topic %s: %s", topic, e)
+    except Exception as e:
+        logger.error("Unexpected error unsubscribing from topic %s: %s", topic, e)
 
 
 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()
+    """Process events concurrently - runs on main thread."""
+    logger.info("Starting event queue processor on main thread")
     background_tasks = set()
 
     def _handle_task_result(task: asyncio.Task) -> None:
@@ -291,17 +415,7 @@ async def _process_event_request(event: EventRequest) -> None:
     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
+    await _send_message(dest_socket, result_event.json(), topic=result_event.response_topic)
 
 
 async def _process_app_event(event: AppEvent) -> None:
@@ -309,7 +423,7 @@ async def _process_app_event(event: AppEvent) -> None:
     # Let Griptape Nodes broadcast it.
     await griptape_nodes.broadcast_app_event(event.payload)
 
-    await __emit_message("app_event", event.json())
+    await _send_message("app_event", event.json())
 
 
 async def _process_node_event(event: GriptapeNodeEvent) -> None:
@@ -324,12 +438,12 @@ async def _process_node_event(event: GriptapeNodeEvent) -> None:
         msg = f"Unknown/unsupported result event type encountered: '{type(result_event)}'."
         raise TypeError(msg) from None
 
-    await __emit_message(dest_socket, result_event.json(), topic=result_event.response_topic)
+    await _send_message(dest_socket, result_event.json(), topic=result_event.response_topic)
 
 
 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())
+    await _send_message("execution_event", event.wrapped_event.json())
 
 
 async def _process_progress_event(gt_event: ProgressEvent) -> None:
@@ -341,41 +455,47 @@ async 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)
-        await __emit_message("execution_event", event_to_emit.json())
+        await _send_message("execution_event", event_to_emit.json())
 
 
-def _create_websocket_connection(api_key: str) -> Any:
-    """Create an async WebSocket connection to the Nodes API."""
-    endpoint = urljoin(
-        os.getenv("GRIPTAPE_NODES_API_BASE_URL", "https://api.nodes.griptape.ai").replace("http", "ws"),
-        "/ws/engines/events?version=v2",
-    )
+async def _send_message(event_type: str, payload: str, topic: str | None = None) -> None:
+    """Queue a message to be sent via WebSocket using run_coroutine_threadsafe."""
+    # Wait for websocket event loop to be ready
+    websocket_event_loop_ready.wait()
+
+    # Use run_coroutine_threadsafe to put message into WebSocket background thread queue
+    if websocket_event_loop is None:
+        logger.error("WebSocket event loop not available for message")
+        return
+
+    # Determine topic based on session_id and engine_id in the payload
+    if topic is None:
+        topic = determine_response_topic()
+
+    message = WebSocketMessage(event_type, payload, topic)
+
+    asyncio.run_coroutine_threadsafe(ws_outgoing_queue.put(message), websocket_event_loop)
 
-    return connect(
-        endpoint,
-        additional_headers={"Authorization": f"Bearer {api_key}"},
-    )
 
+async def subscribe_to_topic(topic: str) -> None:
+    """Queue a subscribe command for WebSocket using run_coroutine_threadsafe."""
+    # Wait for websocket event loop to be ready
+    websocket_event_loop_ready.wait()
 
-async def __emit_message(event_type: str, payload: str, topic: str | None = None) -> None:
-    """Send a message via WebSocket asynchronously."""
-    ws_connection = ws_connection_context.get()
-    if ws_connection is None:
-        logger.warning("WebSocket connection not available for sending message")
+    if websocket_event_loop is None:
+        logger.error("WebSocket event loop not available for subscribe")
         return
 
-    try:
-        # Determine topic based on session_id and engine_id in the payload
-        if topic is None:
-            topic = determine_response_topic()
+    asyncio.run_coroutine_threadsafe(ws_outgoing_queue.put(SubscribeCommand(topic)), websocket_event_loop)
 
-        body = {"type": event_type, "payload": json.loads(payload), "topic": topic}
 
-        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)
+async def unsubscribe_from_topic(topic: str) -> None:
+    """Queue an unsubscribe command for WebSocket using run_coroutine_threadsafe."""
+    if websocket_event_loop is None:
+        logger.error("WebSocket event loop not available for unsubscribe")
+        return
+
+    asyncio.run_coroutine_threadsafe(ws_outgoing_queue.put(UnsubscribeCommand(topic)), websocket_event_loop)
 
 
 def determine_response_topic() -> str | None:
@@ -412,76 +532,3 @@ def determine_request_topic() -> str | None:
 
     # Default to generic request topic
     return "request"
-
-
-async def subscribe_to_topic(topic: str) -> None:
-    """Subscribe to a specific topic in the message bus."""
-    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.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)
-    except Exception as e:
-        logger.error("Unexpected error while subscribing to topic %s: %s", topic, e)
-
-
-async def unsubscribe_from_topic(topic: str) -> None:
-    """Unsubscribe from a specific topic in the message bus."""
-    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.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)
-    except Exception as e:
-        logger.error("Unexpected error while unsubscribing from topic %s: %s", topic, e)
-
-
-async def _process_api_event(event: dict) -> None:
-    """Process API events and add to async queue."""
-    payload = event.get("payload", {})
-
-    try:
-        payload["request"]
-    except KeyError:
-        msg = "Error: 'request' was expected but not found."
-        raise RuntimeError(msg) from None
-
-    try:
-        event_type = payload["event_type"]
-        if event_type != "EventRequest":
-            msg = "Error: 'event_type' was found on request, but did not match 'EventRequest' as expected."
-            raise RuntimeError(msg) from None
-    except KeyError:
-        msg = "Error: 'event_type' not found in request."
-        raise RuntimeError(msg) from None
-
-    # Now attempt to convert it into an EventRequest.
-    try:
-        request_event = deserialize_event(json_data=payload)
-    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
-        await _process_event_request(request_event)
-    else:
-        # Add the event to the async queue for normal processing
-        await griptape_nodes.EventManager().aput_event(request_event)

griptape_nodes/cli/__init__.py

@@ -0,0 +1 @@
+"""Griptape Nodes CLI module."""

griptape_nodes/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Griptape Nodes CLI commands."""