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

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
@@ -18,6 +18,8 @@ from rich.panel import Panel
 from websockets.asyncio.client import connect
 from websockets.exceptions import ConnectionClosed, 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,11 +38,41 @@ 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
+
+
+@dataclass
+class SubscribeCommand:
+    """Command to subscribe to a topic."""
+
+    topic: str
+
+
+@dataclass
+class UnsubscribeCommand:
+    """Command to unsubscribe from a topic."""
+
+    topic: str
+
+
+# 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
@@ -95,62 +127,84 @@ 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 daemon thread
+        threading.Thread(target=start_mcp_server, args=(api_key,), daemon=True, name="mcp-server").start()
 
-        # Start MCP server in thread
-        server_tasks.append(asyncio.to_thread(_run_mcp_server_sync, api_key))
-
-        # 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:
+        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:
@@ -179,70 +233,156 @@ 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")
-
-    connection_stream = _create_websocket_connection(api_key)
-    initialized = False
+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")
 
     try:
-        async for ws_connection in connection_stream:
-            await _handle_websocket_connection(ws_connection, initialized=initialized)
-            initialized = True
+        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("Fatal error in WebSocket listener: %s", e)
+        logger.error("Error in WebSocket connection. Retrying in 2 seconds... %s", e)
+        await asyncio.sleep(2.0)
         raise
     finally:
-        await _cleanup_websocket_connection()
+        logger.info("WebSocket listener shutdown complete")
 
 
-async def _handle_websocket_connection(ws_connection: Any, *, initialized: bool) -> None:
-    """Handle a single WebSocket connection."""
+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:
-        ws_connection_context.set(ws_connection)
-        ws_ready_event.set()
+        payload["request"]
+    except KeyError:
+        msg = "Error: 'request' was expected but not found."
+        raise RuntimeError(msg) from None
 
-        if not initialized:
-            await griptape_nodes.EventManager().aput_event(AppEvent(payload=app_events.AppInitializationComplete()))
+    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
 
-        await griptape_nodes.EventManager().aput_event(AppEvent(payload=app_events.AppConnectionEstablished()))
+    # 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()
 
-        async for message in ws_connection:
             try:
-                data = json.loads(message)
-                await _process_api_event(data)
-            except Exception:
-                logger.exception("Error processing event, skipping.")
+                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 ConnectionClosed:
-        logger.info("WebSocket connection closed, will retry")
+    except asyncio.CancelledError:
+        logger.info("Outbound request sender shutdown complete")
+        raise
     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("Fatal error in outgoing request sender: %s", e)
+        raise
 
 
-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_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 - 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 +431,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 +439,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 +454,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 +471,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()
 
-    return connect(
-        endpoint,
-        additional_headers={"Authorization": f"Bearer {api_key}"},
-    )
+    # 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)
 
 
-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")
+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()
+
+    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 +548,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/mcp_server/server.py

@@ -69,7 +69,7 @@ mcp_server_logger.addHandler(RichHandler(show_time=True, show_path=False, markup
 mcp_server_logger.setLevel(logging.INFO)
 
 
-def main_sync(api_key: str) -> None:
+def start_mcp_server(api_key: str) -> None:
     """Synchronous version of main entry point for the Griptape Nodes MCP server."""
     mcp_server_logger.debug("Starting MCP GTN server...")
     # Give these a session ID

{griptape_nodes-0.52.0.dist-info → griptape_nodes-0.52.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: griptape-nodes
-Version: 0.52.0
+Version: 0.52.1
 Summary: Add your description here
 Requires-Dist: griptape>=1.8.2
 Requires-Dist: pydantic>=2.10.6

{griptape_nodes-0.52.0.dist-info → griptape_nodes-0.52.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
 griptape_nodes/__init__.py,sha256=gKRELLnKTgmejKncdssrWFz7k0Aj_Fx7TatcEJB9H-A,37424
 griptape_nodes/app/.python-version,sha256=e1X45ntWI8S-8_ppEojalDfXnTq6FW3kjUgdsyrH0W0,5
 griptape_nodes/app/__init__.py,sha256=DB-DTsgcNnbmEClXEouwzGhrmo3gHBCWXB9BkPGpdQI,90
-griptape_nodes/app/api.py,sha256=w-6FRXRo5yrgnYYG8ClUKVLO0nhKso9nSOJD-P9iRLw,6858
-griptape_nodes/app/app.py,sha256=8r06kohQrY2vv0xhcTg1tig3ZUfUZ4HtUwfML3rYNus,17958
+griptape_nodes/app/api.py,sha256=5IQgyXtcJeppwBpGmLdAQCOc5kh0KX2t1WOqkpo8P30,6579
+griptape_nodes/app/app.py,sha256=OoRVe4QR5DTOVPywZF_ffLsGWt7cBR33VviFGSY_cmA,20727
 griptape_nodes/app/watch.py,sha256=WE3P0Hl_jDezqy_UetNK2K5NTQFYKcoEbcKwzRWY4MU,2648
 griptape_nodes/bootstrap/__init__.py,sha256=ENv3SIzQ9TtlRrg1y4e4CnoBpJaFpFSkNpTFBV8X5Ls,25
 griptape_nodes/bootstrap/workflow_executors/__init__.py,sha256=pyjN81-eLtjyECFYLXOtMCixiiI9qBi5yald86iM7Ek,34
@@ -25,7 +25,7 @@ griptape_nodes/machines/control_flow.py,sha256=x-GlCjfMp-B1BvElcIOxOHtXADx1eK1JN
 griptape_nodes/machines/fsm.py,sha256=JXf4VgaLMEcjDuCxuKyWlAmK5PCOrWHsMau6OPjhL3s,2344
 griptape_nodes/machines/node_resolution.py,sha256=ruvSI5_q6S1O5kNypavxT-feduQpVEvRKrF5ZTPJdL8,18458
 griptape_nodes/mcp_server/__init__.py,sha256=GSpJWqE4lICaryhsQR1okeMH2x6j1bBL0HVxtr52WLg,42
-griptape_nodes/mcp_server/server.py,sha256=7UvgUIATvG9gVD17bHwfWzerm6L5ME8qY319tnlkzac,5210
+griptape_nodes/mcp_server/server.py,sha256=X1ulGyHqQCFiRnJ8PgJh4lf83k62a_D9vFQThgKUaMw,5217
 griptape_nodes/mcp_server/ws_request_manager.py,sha256=UpXOKNq_VauQmJ0Rx0C7OrzcwjeCoDfjpx3IE38NgsE,10949
 griptape_nodes/node_library/__init__.py,sha256=U3FcSdmq6UW7qt6E3Up3NWKvUEn5_5lqL-u5qbzfxMQ,28
 griptape_nodes/node_library/advanced_node_library.py,sha256=B1ZaxuFIzQ6tx_3MLIxlsHuahthEC1Hw_t6K_ByIdzs,2104
@@ -124,7 +124,7 @@ griptape_nodes/version_compatibility/versions/v0_39_0/modified_parameters_set_re
 griptape_nodes/version_compatibility/workflow_versions/__init__.py,sha256=z5XDgkizoNByCXpyo34hfsJKFsWlOHbD6hgzfYH9ubc,52
 griptape_nodes/version_compatibility/workflow_versions/v0_7_0/__init__.py,sha256=IzPPmGK86h2swfGGTOHyVcBIlOng6SjgWQzlbf3ngmo,51
 griptape_nodes/version_compatibility/workflow_versions/v0_7_0/local_executor_argument_addition.py,sha256=9PclAp_Mm5IPtd5yj5XSS5-x7QYmifvhTly20CgBZmo,2018
-griptape_nodes-0.52.0.dist-info/WHEEL,sha256=Jb20R3Ili4n9P1fcwuLup21eQ5r9WXhs4_qy7VTrgPI,79
-griptape_nodes-0.52.0.dist-info/entry_points.txt,sha256=qvevqd3BVbAV5TcantnAm0ouqaqYKhsRO3pkFymWLWM,82
-griptape_nodes-0.52.0.dist-info/METADATA,sha256=Syb9Euum5ggkxmZA554heaE0qb4Qc6MAd1cXHWMevx4,4943
-griptape_nodes-0.52.0.dist-info/RECORD,,
+griptape_nodes-0.52.1.dist-info/WHEEL,sha256=Jb20R3Ili4n9P1fcwuLup21eQ5r9WXhs4_qy7VTrgPI,79
+griptape_nodes-0.52.1.dist-info/entry_points.txt,sha256=qvevqd3BVbAV5TcantnAm0ouqaqYKhsRO3pkFymWLWM,82
+griptape_nodes-0.52.1.dist-info/METADATA,sha256=SvH75XQLx75G84IO6Sgb2Q8yq8PRzFKPeJ3dt5uaB3A,4943
+griptape_nodes-0.52.1.dist-info/RECORD,,