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

griptape_nodes/machines/control_flow.py

@@ -5,8 +5,6 @@ import logging
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
-from griptape.events import EventBus
-
 from griptape_nodes.exe_types.core_types import Parameter
 from griptape_nodes.exe_types.node_types import BaseNode, NodeResolutionState
 from griptape_nodes.exe_types.type_validator import TypeValidator
@@ -18,6 +16,7 @@ from griptape_nodes.retained_mode.events.execution_events import (
     CurrentControlNodeEvent,
     SelectedControlOutputEvent,
 )
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
 
 @dataclass
@@ -54,8 +53,6 @@ class ControlFlowContext:
             NextNodeInfo | None: Information about the next node or None if no connection
         """
         if self.current_node is not None:
-            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
-
             node_connection = (
                 GriptapeNodes.FlowManager().get_connections().get_connected_node(self.current_node, output_parameter)
             )
@@ -81,7 +78,7 @@ class ControlFlowContext:
 # GOOD!
 class ResolveNodeState(State):
     @staticmethod
-    def on_enter(context: ControlFlowContext) -> type[State] | None:
+    async def on_enter(context: ControlFlowContext) -> type[State] | None:
         # The state machine has started, but it hasn't began to execute yet.
         if context.current_node is None:
             # We don't have anything else to do. Move back to Complete State so it has to restart.
@@ -95,7 +92,7 @@ class ResolveNodeState(State):
                 )
             )
         # Now broadcast that we have a current control node.
-        EventBus.publish_event(
+        GriptapeNodes.EventManager().put_event(
             ExecutionGriptapeNodeEvent(
                 wrapped_event=ExecutionEvent(payload=CurrentControlNodeEvent(node_name=context.current_node.name))
             )
@@ -108,12 +105,12 @@ class ResolveNodeState(State):
 
     # This is necessary to transition to the next step.
     @staticmethod
-    def on_update(context: ControlFlowContext) -> type[State] | None:
+    async def on_update(context: ControlFlowContext) -> type[State] | None:
         # If node has not already been resolved!
         if context.current_node is None:
             return CompleteState
         if context.current_node.state != NodeResolutionState.RESOLVED:
-            context.resolution_machine.resolve_node(context.current_node)
+            await context.resolution_machine.resolve_node(context.current_node)
 
         if context.resolution_machine.is_complete():
             return NextNodeState
@@ -122,7 +119,7 @@ class ResolveNodeState(State):
 
 class NextNodeState(State):
     @staticmethod
-    def on_enter(context: ControlFlowContext) -> type[State] | None:
+    async def on_enter(context: ControlFlowContext) -> type[State] | None:
         if context.current_node is None:
             return CompleteState
         # I did define this on the ControlNode.
@@ -136,7 +133,7 @@ class NextNodeState(State):
         if next_output is not None:
             context.selected_output = next_output
             next_node_info = context.get_next_node(context.selected_output)
-            EventBus.publish_event(
+            GriptapeNodes.EventManager().put_event(
                 ExecutionGriptapeNodeEvent(
                     wrapped_event=ExecutionEvent(
                         payload=SelectedControlOutputEvent(
@@ -147,8 +144,6 @@ class NextNodeState(State):
                 )
             )
         else:
-            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
-
             # Get the next node in the execution queue, or None if queue is empty
             next_node = GriptapeNodes.FlowManager().get_next_node_from_execution_queue()
             if next_node is not None:
@@ -169,15 +164,15 @@ class NextNodeState(State):
         return None
 
     @staticmethod
-    def on_update(context: ControlFlowContext) -> type[State] | None:  # noqa: ARG004
+    async def on_update(context: ControlFlowContext) -> type[State] | None:  # noqa: ARG004
         return ResolveNodeState
 
 
 class CompleteState(State):
     @staticmethod
-    def on_enter(context: ControlFlowContext) -> type[State] | None:
+    async def on_enter(context: ControlFlowContext) -> type[State] | None:
         if context.current_node is not None:
-            EventBus.publish_event(
+            GriptapeNodes.EventManager().put_event(
                 ExecutionGriptapeNodeEvent(
                     wrapped_event=ExecutionEvent(
                         payload=ControlFlowResolvedEvent(
@@ -193,7 +188,7 @@ class CompleteState(State):
         return None
 
     @staticmethod
-    def on_update(context: ControlFlowContext) -> type[State] | None:  # noqa: ARG004
+    async def on_update(context: ControlFlowContext) -> type[State] | None:  # noqa: ARG004
         return None
 
 
@@ -203,46 +198,46 @@ class ControlFlowMachine(FSM[ControlFlowContext]):
         context = ControlFlowContext()
         super().__init__(context)
 
-    def start_flow(self, start_node: BaseNode, debug_mode: bool = False) -> None:  # noqa: FBT001, FBT002
+    async def start_flow(self, start_node: BaseNode, debug_mode: bool = False) -> None:  # noqa: FBT001, FBT002
         self._context.current_node = start_node
         # Set entry control parameter for initial node (None for workflow start)
         start_node.set_entry_control_parameter(None)
         # Set up to debug
         self._context.paused = debug_mode
-        self.start(ResolveNodeState)  # Begins the flow
+        await self.start(ResolveNodeState)  # Begins the flow
 
-    def update(self) -> None:
+    async def update(self) -> None:
         if self._current_state is None:
             msg = "Attempted to run the next step of a workflow that was either already complete or has not started."
             raise RuntimeError(msg)
-        super().update()
+        await super().update()
 
     def change_debug_mode(self, debug_mode: bool) -> None:  # noqa: FBT001
         self._context.paused = debug_mode
         self._context.resolution_machine.change_debug_mode(debug_mode)
 
-    def granular_step(self, change_debug_mode: bool) -> None:  # noqa: FBT001
+    async def granular_step(self, change_debug_mode: bool) -> None:  # noqa: FBT001
         resolution_machine = self._context.resolution_machine
         if change_debug_mode:
             resolution_machine.change_debug_mode(True)
-        resolution_machine.update()
+        await resolution_machine.update()
 
         # Tick the control flow if the resolution machine inside it isn't busy.
         if resolution_machine.is_complete() or not resolution_machine.is_started():  # noqa: SIM102
             # Don't tick ourselves if we are already complete.
             if self._current_state is not None:
-                self.update()
+                await self.update()
 
-    def node_step(self) -> None:
+    async def node_step(self) -> None:
         resolution_machine = self._context.resolution_machine
         resolution_machine.change_debug_mode(False)
-        resolution_machine.update()
+        await resolution_machine.update()
 
         # Tick the control flow if the resolution machine inside it isn't busy.
         if resolution_machine.is_complete() or not resolution_machine.is_started():  # noqa: SIM102
             # Don't tick ourselves if we are already complete.
             if self._current_state is not None:
-                self.update()
+                await self.update()
 
     def reset_machine(self) -> None:
         self._context.reset()

griptape_nodes/machines/fsm.py

@@ -5,22 +5,22 @@ T = TypeVar("T")
 
 class State:
     @staticmethod
-    def on_enter(context: Any) -> type["State"] | None:  # noqa: ARG004
+    async def on_enter(context: Any) -> type["State"] | None:  # noqa: ARG004
         """Called when entering the state."""
         return None
 
     @staticmethod
-    def on_update(context: Any) -> type["State"] | None:  # noqa: ARG004
+    async def on_update(context: Any) -> type["State"] | None:  # noqa: ARG004
         """Called each update until a transition occurs."""
         return None
 
     @staticmethod
-    def on_exit(context: Any) -> None:  # noqa: ARG004
+    async def on_exit(context: Any) -> None:  # noqa: ARG004
         """Called when exiting the state."""
         return
 
     @staticmethod
-    def on_event(context: Any, event: Any) -> type["State"] | None:  # noqa: ARG004
+    async def on_event(context: Any, event: Any) -> type["State"] | None:  # noqa: ARG004
         """Called on an event, which may trigger a State transition."""
         return None
 
@@ -30,40 +30,40 @@ class FSM[T]:
         self._context = context
         self._current_state = None
 
-    def start(self, initial_state: type[State]) -> None:
+    async def start(self, initial_state: type[State]) -> None:
         # Enter the initial state.
-        self.transition_state(initial_state)
+        await self.transition_state(initial_state)
 
     def get_current_state(self) -> type[State] | None:
         return self._current_state
 
-    def transition_state(self, new_state: type[State] | None) -> None:
+    async def transition_state(self, new_state: type[State] | None) -> None:
         while new_state is not None:
             # Exit the current state.
             if self._current_state is not None and new_state is self._current_state:
-                new_state = self._current_state.on_update(self._context)
+                new_state = await self._current_state.on_update(self._context)
                 continue
             if self._current_state is not None:
-                self._current_state.on_exit(self._context)
+                await self._current_state.on_exit(self._context)
             # Update current
             self._current_state = new_state
             # Enter the now-current state
-            new_state = self._current_state.on_enter(self._context)
+            new_state = await self._current_state.on_enter(self._context)
 
-    def update(self) -> None:
+    async def update(self) -> None:
         if self._current_state is None:
             new_state = None
         else:
-            new_state = self._current_state.on_update(self._context)
+            new_state = await self._current_state.on_update(self._context)
 
         if new_state is not None:
-            self.transition_state(new_state)
+            await self.transition_state(new_state)
 
-    def handle_event(self, event: Any) -> None:
+    async def handle_event(self, event: Any) -> None:
         if self._current_state is None:
             new_state = None
         else:
-            new_state = self._current_state.on_event(self._context, event)
+            new_state = await self._current_state.on_event(self._context, event)
 
         if new_state is not None:
-            self.transition_state(new_state)
+            await self.transition_state(new_state)

griptape_nodes/machines/node_resolution.py

@@ -1,13 +1,7 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import Generator
-from concurrent.futures import Future, ThreadPoolExecutor
 from dataclasses import dataclass
-from typing import Any
-
-from griptape.events import EventBus
-from griptape.utils import with_contextvars
 
 from griptape_nodes.exe_types.core_types import ParameterType, ParameterTypeBuiltin
 from griptape_nodes.exe_types.node_types import BaseNode, NodeResolutionState
@@ -25,11 +19,11 @@ from griptape_nodes.retained_mode.events.execution_events import (
     NodeStartProcessEvent,
     ParameterSpotlightEvent,
     ParameterValueUpdateEvent,
-    ResumeNodeProcessingEvent,
 )
 from griptape_nodes.retained_mode.events.parameter_events import (
     SetParameterValueRequest,
 )
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
 logger = logging.getLogger("griptape_nodes")
 
@@ -37,8 +31,6 @@ logger = logging.getLogger("griptape_nodes")
 @dataclass
 class Focus:
     node: BaseNode
-    scheduled_value: Any | None = None
-    process_generator: Generator | None = None
 
 
 # This is on a per-node basis
@@ -55,18 +47,16 @@ class ResolutionContext:
             node = self.focus_stack[-1].node
             # clear the data node being resolved.
             node.clear_node()
-            self.focus_stack[-1].process_generator = None
-            self.focus_stack[-1].scheduled_value = None
         self.focus_stack.clear()
         self.paused = False
 
 
 class InitializeSpotlightState(State):
     @staticmethod
-    def on_enter(context: ResolutionContext) -> type[State] | None:
+    async def on_enter(context: ResolutionContext) -> type[State] | None:
         # If the focus stack is empty
         current_node = context.focus_stack[-1].node
-        EventBus.publish_event(
+        GriptapeNodes.EventManager().put_event(
             ExecutionGriptapeNodeEvent(
                 wrapped_event=ExecutionEvent(payload=CurrentDataNodeEvent(node_name=current_node.name))
             )
@@ -76,7 +66,7 @@ class InitializeSpotlightState(State):
         return None
 
     @staticmethod
-    def on_update(context: ResolutionContext) -> type[State] | None:
+    async def on_update(context: ResolutionContext) -> type[State] | None:
         # If the focus stack is empty
         if not len(context.focus_stack):
             return CompleteState
@@ -104,13 +94,13 @@ class InitializeSpotlightState(State):
 
 class EvaluateParameterState(State):
     @staticmethod
-    def on_enter(context: ResolutionContext) -> type[State] | None:
+    async def on_enter(context: ResolutionContext) -> type[State] | None:
         current_node = context.focus_stack[-1].node
         current_parameter = current_node.get_current_parameter()
         if current_parameter is None:
             return ExecuteNodeState
         # if not in debug mode - keep going!
-        EventBus.publish_event(
+        GriptapeNodes.EventManager().put_event(
             ExecutionGriptapeNodeEvent(
                 wrapped_event=ExecutionEvent(
                     payload=ParameterSpotlightEvent(
@@ -125,7 +115,7 @@ class EvaluateParameterState(State):
         return None
 
     @staticmethod
-    def on_update(context: ResolutionContext) -> type[State] | None:
+    async def on_update(context: ResolutionContext) -> type[State] | None:
         current_node = context.focus_stack[-1].node
         current_parameter = current_node.get_current_parameter()
         from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
@@ -153,11 +143,9 @@ class EvaluateParameterState(State):
 
 
 class ExecuteNodeState(State):
-    executor: ThreadPoolExecutor = ThreadPoolExecutor()
-
     # TODO: https://github.com/griptape-ai/griptape-nodes/issues/864
     @staticmethod
-    def clear_parameter_output_values(context: ResolutionContext) -> None:
+    async def clear_parameter_output_values(context: ResolutionContext) -> None:
         """Clears all parameter output values for the currently focused node in the resolution context.
 
         This method iterates through each parameter output value stored in the current node,
@@ -192,11 +180,13 @@ class ExecuteNodeState(State):
                 data_type=parameter_type,
                 value=None,
             )
-            EventBus.publish_event(ExecutionGriptapeNodeEvent(wrapped_event=ExecutionEvent(payload=payload)))
+            GriptapeNodes.EventManager().put_event(
+                ExecutionGriptapeNodeEvent(wrapped_event=ExecutionEvent(payload=payload))
+            )
         current_node.parameter_output_values.clear()
 
     @staticmethod
-    def collect_values_from_upstream_nodes(context: ResolutionContext) -> None:
+    async def collect_values_from_upstream_nodes(context: ResolutionContext) -> None:
         """Collect output values from resolved upstream nodes and pass them to the current node.
 
         This method iterates through all input parameters of the current node, finds their
@@ -240,19 +230,21 @@ class ExecuteNodeState(State):
                             node_name=current_node.name,
                             value=output_value,
                             data_type=upstream_parameter.output_type,
+                            incoming_connection_source_node_name=upstream_node.name,
+                            incoming_connection_source_parameter_name=upstream_parameter.name,
                         )
                     )
 
     @staticmethod
-    def on_enter(context: ResolutionContext) -> type[State] | None:
+    async def on_enter(context: ResolutionContext) -> type[State] | None:
         current_node = context.focus_stack[-1].node
 
         # Clear all of the current output values
         # if node is locked, don't clear anything. skip all of this.
         if current_node.lock:
             return ExecuteNodeState
-        ExecuteNodeState.collect_values_from_upstream_nodes(context)
-        ExecuteNodeState.clear_parameter_output_values(context)
+        await ExecuteNodeState.collect_values_from_upstream_nodes(context)
+        await ExecuteNodeState.clear_parameter_output_values(context)
         for parameter in current_node.parameters:
             if ParameterTypeBuiltin.CONTROL_TYPE.value.lower() == parameter.output_type:
                 continue
@@ -267,7 +259,7 @@ class ExecuteNodeState(State):
                 data_type = parameter.type
                 if data_type is None:
                     data_type = ParameterTypeBuiltin.NONE.value
-                EventBus.publish_event(
+                GriptapeNodes.EventManager().put_event(
                     ExecutionGriptapeNodeEvent(
                         wrapped_event=ExecutionEvent(
                             payload=ParameterValueUpdateEvent(
@@ -291,7 +283,7 @@ class ExecuteNodeState(State):
         return None
 
     @staticmethod
-    def on_update(context: ResolutionContext) -> type[State] | None:
+    async def on_update(context: ResolutionContext) -> type[State] | None:
         from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
         # Once everything has been set
@@ -300,18 +292,16 @@ class ExecuteNodeState(State):
         # If the node is not locked, execute all of this.
         if not current_node.lock:
             # To set the event manager without circular import errors
-            EventBus.publish_event(
+            GriptapeNodes.EventManager().put_event(
                 ExecutionGriptapeNodeEvent(
                     wrapped_event=ExecutionEvent(payload=NodeStartProcessEvent(node_name=current_node.name))
                 )
             )
             logger.info("Node '%s' is processing.", current_node.name)
+            current_node = current_focus.node
 
             try:
-                work_is_scheduled = ExecuteNodeState._process_node(current_focus)
-                if work_is_scheduled:
-                    logger.debug("Pausing Node '%s' to run background work", current_node.name)
-                    return None
+                await current_node.aprocess()
             except Exception as e:
                 logger.exception("Error processing node '%s", current_node.name)
                 msg = f"Canceling flow run. Node '{current_node.name}' encountered a problem: {e}"
@@ -321,14 +311,12 @@ class ExecuteNodeState(State):
                         {NodeResolutionState.UNRESOLVED, NodeResolutionState.RESOLVED, NodeResolutionState.RESOLVING}
                     )
                 )
-                current_focus.process_generator = None
-                current_focus.scheduled_value = None
 
                 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
                 GriptapeNodes.FlowManager().cancel_flow_run()
 
-                EventBus.publish_event(
+                GriptapeNodes.EventManager().put_event(
                     ExecutionGriptapeNodeEvent(
                         wrapped_event=ExecutionEvent(payload=NodeFinishProcessEvent(node_name=current_node.name))
                     )
@@ -337,7 +325,7 @@ class ExecuteNodeState(State):
 
             logger.info("Node '%s' finished processing.", current_node.name)
 
-            EventBus.publish_event(
+            GriptapeNodes.EventManager().put_event(
                 ExecutionGriptapeNodeEvent(
                     wrapped_event=ExecutionEvent(payload=NodeFinishProcessEvent(node_name=current_node.name))
                 )
@@ -363,7 +351,7 @@ class ExecuteNodeState(State):
                 data_type = parameter.type
                 if data_type is None:
                     data_type = ParameterTypeBuiltin.NONE.value
-                EventBus.publish_event(
+                GriptapeNodes.EventManager().put_event(
                     ExecutionGriptapeNodeEvent(
                         wrapped_event=ExecutionEvent(
                             payload=ParameterValueUpdateEvent(
@@ -381,7 +369,7 @@ class ExecuteNodeState(State):
             library_name = library[0]
         else:
             library_name = None
-        EventBus.publish_event(
+        GriptapeNodes.EventManager().put_event(
             ExecutionGriptapeNodeEvent(
                 wrapped_event=ExecutionEvent(
                     payload=NodeResolvedEvent(
@@ -399,91 +387,14 @@ class ExecuteNodeState(State):
 
         return CompleteState
 
-    @staticmethod
-    def _process_node(current_focus: Focus) -> bool:
-        """Run the process method of the node.
-
-        If the node's process method returns a generator, take the next value from the generator (a callable) and run
-        that in a thread pool executor. The result of that callable will be passed to the generator when it is resumed.
-
-        This has the effect of pausing at a yield expression, running the expression in a thread, and resuming when the thread pool is done.
-
-        Args:
-            current_focus (Focus): The current focus.
-
-        Returns:
-            bool: True if work has been scheduled, False if the node is done processing.
-        """
-
-        def on_future_done(future: Future) -> None:
-            """Called when the future is done.
-
-            Stores the result of the future in the node's context, and publishes an event to resume the flow.
-            """
-            try:
-                current_focus.scheduled_value = future.result()
-            except Exception as e:
-                logger.debug("Error in future: %s", e)
-                current_focus.scheduled_value = e
-            finally:
-                # If it hasn't been cancelled.
-                if current_focus.process_generator:
-                    EventBus.publish_event(
-                        ExecutionGriptapeNodeEvent(
-                            wrapped_event=ExecutionEvent(payload=ResumeNodeProcessingEvent(node_name=current_node.name))
-                        )
-                    )
-
-        current_node = current_focus.node
-        # Only start the processing if we don't already have a generator
-        logger.debug("Node '%s' process generator: %s", current_node.name, current_focus.process_generator)
-        if current_focus.process_generator is None:
-            result = current_node.process()
-
-            # If the process returned a generator, we need to store it for later
-            if isinstance(result, Generator):
-                current_focus.process_generator = result
-                logger.debug("Node '%s' returned a generator.", current_node.name)
-
-        # We now have a generator, so we need to run it
-        if current_focus.process_generator is not None:
-            try:
-                logger.debug(
-                    "Node '%s' has an active generator, sending scheduled value of type: %s",
-                    current_node.name,
-                    type(current_focus.scheduled_value),
-                )
-                if isinstance(current_focus.scheduled_value, Exception):
-                    func = current_focus.process_generator.throw(current_focus.scheduled_value)
-                else:
-                    func = current_focus.process_generator.send(current_focus.scheduled_value)
-
-                # Once we've passed on the scheduled value, we should clear it out just in case
-                current_focus.scheduled_value = None
-
-                future = ExecuteNodeState.executor.submit(with_contextvars(func))
-                future.add_done_callback(with_contextvars(on_future_done))
-            except StopIteration:
-                logger.debug("Node '%s' generator is done.", current_node.name)
-                # If that was the last generator, clear out the generator and indicate that there is no more work scheduled
-                current_focus.process_generator = None
-                current_focus.scheduled_value = None
-                return False
-            else:
-                # If the generator is not done, indicate that there is work scheduled
-                logger.debug("Node '%s' generator is not done.", current_node.name)
-                return True
-        logger.debug("Node '%s' did not return a generator.", current_node.name)
-        return False
-
 
 class CompleteState(State):
     @staticmethod
-    def on_enter(context: ResolutionContext) -> type[State] | None:  # noqa: ARG004
+    async def on_enter(context: ResolutionContext) -> type[State] | None:  # noqa: ARG004
         return None
 
     @staticmethod
-    def on_update(context: ResolutionContext) -> type[State] | None:  # noqa: ARG004
+    async def on_update(context: ResolutionContext) -> type[State] | None:  # noqa: ARG004
         return None
 
 
@@ -494,9 +405,9 @@ class NodeResolutionMachine(FSM[ResolutionContext]):
         resolution_context = ResolutionContext()
         super().__init__(resolution_context)
 
-    def resolve_node(self, node: BaseNode) -> None:
+    async def resolve_node(self, node: BaseNode) -> None:
         self._context.focus_stack.append(Focus(node=node))
-        self.start(InitializeSpotlightState)
+        await self.start(InitializeSpotlightState)
 
     def change_debug_mode(self, debug_mode: bool) -> None:  # noqa: FBT001
         self._context.paused = debug_mode

griptape_nodes/mcp_server/server.py

@@ -69,8 +69,8 @@ mcp_server_logger.addHandler(RichHandler(show_time=True, show_path=False, markup
 mcp_server_logger.setLevel(logging.INFO)
 
 
-def main(api_key: str) -> None:
-    """Main entry point for the Griptape Nodes MCP server."""
+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
     connection_manager = WebSocketConnectionManager()
@@ -116,7 +116,6 @@ def main(api_key: str) -> None:
             finally:
                 mcp_server_logger.debug("GTN MCP server shutting down...")
 
-    # Create an ASGI application using the transport
     mcp_server_app = FastAPI(lifespan=lifespan)
 
     # ASGI handler for streamable HTTP connections
@@ -125,10 +124,15 @@ def main(api_key: str) -> None:
 
     mcp_server_app.mount("/mcp", app=handle_streamable_http)
 
-    uvicorn.run(
-        mcp_server_app,
-        host=GTN_MCP_SERVER_HOST,
-        port=GTN_MCP_SERVER_PORT,
-        log_config=None,
-        log_level=GTN_MCP_SERVER_LOG_LEVEL,
-    )
+    try:
+        # Run server using uvicorn.run
+        uvicorn.run(
+            mcp_server_app,
+            host=GTN_MCP_SERVER_HOST,
+            port=GTN_MCP_SERVER_PORT,
+            log_config=None,
+            log_level=GTN_MCP_SERVER_LOG_LEVEL,
+        )
+    except Exception as e:
+        mcp_server_logger.error("MCP server failed: %s", e)
+        raise

griptape_nodes/mcp_server/ws_request_manager.py

@@ -190,12 +190,12 @@ class AsyncRequestManager(Generic[T]):  # noqa: UP046
 
     async def create_event(self, request_type: str, payload: dict[str, Any]) -> None:
         """Send an event to the API without waiting for a response."""
-        from griptape_nodes.app.app import _determine_request_topic
+        from griptape_nodes.app.app import determine_request_topic
 
         logger.debug("Creating Event: %s - %s", request_type, json.dumps(payload))
 
         data = {"event_type": "EventRequest", "request_type": request_type, "request": payload}
-        topic = _determine_request_topic()
+        topic = determine_request_topic()
 
         request_data = {"payload": data, "type": data["event_type"], "topic": topic}
 

griptape_nodes/node_library/workflow_registry.py

@@ -69,6 +69,11 @@ class WorkflowRegistry(metaclass=SingletonMeta):
     def get_complete_file_path(cls, relative_file_path: str) -> str:
         from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
+        # If the path is already absolute, return it as-is
+        if Path(relative_file_path).is_absolute():
+            return relative_file_path
+
+        # Otherwise, resolve it relative to the workspace
         config_mgr = GriptapeNodes.ConfigManager()
         workspace_path = config_mgr.workspace_path
         complete_file_path = workspace_path / relative_file_path