griptape-nodes 0.51.2__py3-none-any.whl → 0.52.1__py3-none-any.whl

griptape_nodes/app/app.py

@@ -4,18 +4,13 @@ import asyncio
 import json
 import logging
 import os
-import signal
 import sys
 import threading
+from dataclasses import dataclass
 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,8 @@ 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.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,29 +32,61 @@ 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()
+# WebSocket thread communication message types
+@dataclass
+class WebSocketMessage:
+    """Message to send via WebSocket."""
+
+    event_type: str
+    payload: str
+    topic: str | None = None
+
+
+@dataclass
+class SubscribeCommand:
+    """Command to subscribe to a topic."""
+
+    topic: str
+
+
+@dataclass
+class UnsubscribeCommand:
+    """Command to unsubscribe from a topic."""
 
-# Global WebSocket connection for sending events
-ws_connection_for_sending = None
-event_loop = None
+    topic: str
 
-# Event to signal when WebSocket connection is ready
-ws_ready_event = threading.Event()
+
+# 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)
+
+
+# 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 +95,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 +114,101 @@ 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()
+
+    # Initialize event queue in main thread
+    griptape_nodes.EventManager().initialize_queue()
+
+    # Get main loop reference
+    main_loop = asyncio.get_running_loop()
+
+    try:
+        # 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 daemon thread if enabled
+        if STATIC_SERVER_ENABLED:
+            static_dir = _build_static_dir()
+            threading.Thread(target=start_static_server, args=(static_dir,), daemon=True, name="static-server").start()
+
+        # Start WebSocket tasks in daemon thread
+        threading.Thread(
+            target=_start_websocket_connection, args=(api_key, main_loop), daemon=True, name="websocket-tasks"
+        ).start()
+
+        # Run event processing on main thread
+        await _process_event_queue()
+
+    except Exception as e:
+        logger.error("Application startup failed: %s", e)
+        raise
+
+
+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:
+        # 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()
+
+        # Run the async WebSocket tasks
+        loop.run_until_complete(_run_websocket_tasks(api_key, main_loop))
+    except Exception as e:
+        logger.error("WebSocket thread error: %s", e)
+        raise
+    finally:
+        websocket_event_loop = None
+        websocket_event_loop_ready.clear()
+
+
+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)
+
+    # Track if this is the first connection
+    initialized = False
+
+    async for ws_connection in connection_stream:
+        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* Exception as e:
+            logger.error("WebSocket tasks failed: %s", e.exceptions)
+            await asyncio.sleep(2.0)  # Wait before retry
 
 
 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 +229,221 @@ 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 _process_incoming_messages(ws_connection: Any, main_loop: asyncio.AbstractEventLoop) -> None:
+    """Process incoming WebSocket requests from Nodes API."""
+    logger.info("Processing incoming WebSocket requests from WebSocket connection")
 
-    EventBus.add_event_listener(
-        event_listener=EventListener(
-            on_event=__process_execution_node_event,
-            event_types=[ExecutionGriptapeNodeEvent],
-        )
-    )
+    try:
+        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.")
+
+    except ConnectionClosed:
+        logger.info("WebSocket connection closed, will retry")
+    except asyncio.CancelledError:
+        # Clean shutdown when task is cancelled
+        logger.info("WebSocket listener shutdown complete")
+        raise
+    except Exception as e:
+        logger.error("Error in WebSocket connection. Retrying in 2 seconds... %s", e)
+        await asyncio.sleep(2.0)
+        raise
+    finally:
+        logger.info("WebSocket listener shutdown complete")
 
-    EventBus.add_event_listener(
-        event_listener=EventListener(
-            on_event=__process_progress_event,
-            event_types=[ProgressEvent],
-        )
+
+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",
     )
 
-    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
-        )
+    return connect(
+        endpoint,
+        additional_headers={"Authorization": f"Bearer {api_key}"},
     )
 
 
-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")
+async def _process_api_event(event: dict, main_loop: asyncio.AbstractEventLoop) -> None:
+    """Process API events and add to async queue."""
+    payload = event.get("payload", {})
 
-    # 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
+    try:
+        payload["request"]
+    except KeyError:
+        msg = "Error: 'request' was expected but not found."
+        raise RuntimeError(msg) from None
 
-            if not initialized:
-                event_queue.put(AppEvent(payload=app_events.AppInitializationComplete()))
-                initialized = True
+    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 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.info("Starting outgoing WebSocket request sender")
+
+    try:
+        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()
+
+    except asyncio.CancelledError:
+        logger.info("Outbound request sender shutdown complete")
+        raise
+    except Exception as e:
+        logger.error("Fatal error in outgoing request sender: %s", e)
+        raise
+
+
+async def _send_websocket_message(ws_connection: Any, event_type: str, payload: str, topic: str | None) -> None:
+    """Send a message via WebSocket."""
+    try:
+        if topic is None:
+            topic = determine_response_topic()
+
+        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 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.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 subscribing to topic %s: %s", topic, e)
+
+
+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.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 unsubscribing from topic %s: %s", topic, e)
+
+
+async def _process_event_queue() -> None:
+    """Process events concurrently - runs on main thread."""
+    logger.info("Starting event queue processor on main thread")
+    background_tasks = set()
 
-            event_queue.put(AppEvent(payload=app_events.AppConnectionEstablished()))
+    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())
 
-            async for message in ws_connection:
-                try:
-                    data = json.loads(message)
+    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 _send_message(dest_socket, result_event.json(), topic=result_event.response_topic)
 
-                    _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 _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)
 
-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))
+    await _send_message("app_event", event.json())
 
 
-def __process_node_event(event: GriptapeNodeEvent) -> None:
-    """Process GriptapeNodeEvents and send them to the API."""
+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 +454,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 _send_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 _send_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,82 +471,53 @@ 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()))
+        await _send_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)
+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()
 
-    __schedule_async_task(__emit_message("app_event", event.json()))
+    # 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()
 
-def _process_event_queue() -> None:
-    """Listen for events in the event queue and process them.
+    message = WebSocketMessage(event_type, payload, topic)
 
-    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))
+    asyncio.run_coroutine_threadsafe(ws_outgoing_queue.put(message), websocket_event_loop)
 
-        event_queue.task_done()
 
+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()
 
-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",
-    )
+    if websocket_event_loop is None:
+        logger.error("WebSocket event loop not available for subscribe")
+        return
 
-    return connect(
-        endpoint,
-        additional_headers={"Authorization": f"Bearer {api_key}"},
-    )
+    asyncio.run_coroutine_threadsafe(ws_outgoing_queue.put(SubscribeCommand(topic)), websocket_event_loop)
 
 
-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:
-        logger.warning("WebSocket connection not available for sending message")
+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
 
-    try:
-        # Determine topic based on session_id and engine_id in the payload
-        if topic is None:
-            topic = _determine_response_topic()
-
-        body = {"type": event_type, "payload": json.loads(payload), "topic": topic}
-
-        await ws_connection_for_sending.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)
+    asyncio.run_coroutine_threadsafe(ws_outgoing_queue.put(UnsubscribeCommand(topic)), websocket_event_loop)
 
 
-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 +532,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)
@@ -349,117 +548,3 @@ def _determine_request_topic() -> str | None:
 
     # Default to generic request topic
     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:
-    """Subscribe to a specific topic in the message bus."""
-    if ws_connection_for_sending 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))
-        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 _aunsubscribe_from_topic(topic: str) -> None:
-    """Unsubscribe from a specific topic in the message bus."""
-    if ws_connection_for_sending 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))
-        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)
-
-
-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."""
-    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)
-        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
-
-    # 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))
-    else:
-        # Add the event to the queue for normal processing
-        event_queue.put(request_event)