griptape-nodes 0.43.1__py3-none-any.whl → 0.44.0__py3-none-any.whl

griptape_nodes/exe_types/core_types.py

@@ -244,6 +244,11 @@ class BaseNodeElement:
             "name": self.name,
             "node_name": self._node_context.name,
         }
+        # If ui_options changed, send the complete ui_options from to_dict()
+        complete_dict = self.to_dict()
+        if "ui_options" in complete_dict:
+            self._changes["ui_options"] = complete_dict["ui_options"]
+
         event_data.update(self._changes)
 
         # Publish the event
@@ -384,13 +389,97 @@ class ParameterMessage(BaseNodeElement):
     type VariantType = Literal["info", "warning", "error", "success", "tip", "none"]
 
     element_type: str = field(default_factory=lambda: ParameterMessage.__name__)
-    variant: VariantType
-    title: str | None = None
-    value: str
-    button_link: str | None = None
-    button_text: str | None = None
-    full_width: bool = False
-    ui_options: dict = field(default_factory=dict)
+    _variant: VariantType = field(init=False)
+    _title: str | None = field(default=None, init=False)
+    _value: str = field(init=False)
+    _button_link: str | None = field(default=None, init=False)
+    _button_text: str | None = field(default=None, init=False)
+    _full_width: bool = field(default=False, init=False)
+    _ui_options: dict = field(default_factory=dict, init=False)
+
+    def __init__(  # noqa: PLR0913
+        self,
+        variant: VariantType,
+        value: str,
+        *,
+        title: str | None = None,
+        button_link: str | None = None,
+        button_text: str | None = None,
+        full_width: bool = False,
+        ui_options: dict | None = None,
+        **kwargs,
+    ):
+        super().__init__(element_type=ParameterMessage.__name__, **kwargs)
+        self._variant = variant
+        self._title = title
+        self._value = value
+        self._button_link = button_link
+        self._button_text = button_text
+        self._full_width = full_width
+        self._ui_options = ui_options or {}
+
+    @property
+    def variant(self) -> VariantType:
+        return self._variant
+
+    @variant.setter
+    @BaseNodeElement.emits_update_on_write
+    def variant(self, value: VariantType) -> None:
+        self._variant = value
+
+    @property
+    def title(self) -> str | None:
+        return self._title
+
+    @title.setter
+    @BaseNodeElement.emits_update_on_write
+    def title(self, value: str | None) -> None:
+        self._title = value
+
+    @property
+    def value(self) -> str:
+        return self._value
+
+    @value.setter
+    @BaseNodeElement.emits_update_on_write
+    def value(self, value: str) -> None:
+        self._value = value
+
+    @property
+    def button_link(self) -> str | None:
+        return self._button_link
+
+    @button_link.setter
+    @BaseNodeElement.emits_update_on_write
+    def button_link(self, value: str | None) -> None:
+        self._button_link = value
+
+    @property
+    def button_text(self) -> str | None:
+        return self._button_text
+
+    @button_text.setter
+    @BaseNodeElement.emits_update_on_write
+    def button_text(self, value: str | None) -> None:
+        self._button_text = value
+
+    @property
+    def full_width(self) -> bool:
+        return self._full_width
+
+    @full_width.setter
+    @BaseNodeElement.emits_update_on_write
+    def full_width(self, value: bool) -> None:
+        self._full_width = value
+
+    @property
+    def ui_options(self) -> dict:
+        return self._ui_options
+
+    @ui_options.setter
+    @BaseNodeElement.emits_update_on_write
+    def ui_options(self, value: dict) -> None:
+        self._ui_options = value
 
     def to_dict(self) -> dict[str, Any]:
         data = super().to_dict()
@@ -594,7 +683,7 @@ class Parameter(BaseNodeElement):
         if not element_id:
             element_id = str(uuid.uuid4().hex)
         if not element_type:
-            element_type = BaseNodeElement.__name__
+            element_type = self.__class__.__name__
         super().__init__(element_id=element_id, element_type=element_type)
         self.name = name
         self.tooltip = tooltip
@@ -951,6 +1040,7 @@ class ControlParameter(Parameter, ABC):
         traits: set[Trait.__class__ | Trait] | None = None,
         converters: list[Callable[[Any], Any]] | None = None,
         validators: list[Callable[[Parameter, Any], None]] | None = None,
+        ui_options: dict | None = None,
         *,
         user_defined: bool = False,
     ):
@@ -970,6 +1060,7 @@ class ControlParameter(Parameter, ABC):
             traits=traits,
             converters=converters,
             validators=validators,
+            ui_options=ui_options,
             user_defined=user_defined,
             element_type=self.__class__.__name__,
         )
@@ -980,6 +1071,7 @@ class ControlParameterInput(ControlParameter):
         self,
         tooltip: str | list[dict] = "Connection from previous node in the execution chain",
         name: str = "exec_in",
+        display_name: str | None = "Flow In",
         tooltip_as_input: str | list[dict] | None = None,
         tooltip_as_property: str | list[dict] | None = None,
         tooltip_as_output: str | list[dict] | None = None,
@@ -992,6 +1084,11 @@ class ControlParameterInput(ControlParameter):
         allowed_modes = {ParameterMode.INPUT}
         input_types = [ParameterTypeBuiltin.CONTROL_TYPE.value]
 
+        if display_name is None:
+            ui_options = None
+        else:
+            ui_options = {"display_name": display_name}
+
         # Call parent with a few explicit tweaks.
         super().__init__(
             name=name,
@@ -1005,6 +1102,7 @@ class ControlParameterInput(ControlParameter):
             traits=traits,
             converters=converters,
             validators=validators,
+            ui_options=ui_options,
             user_defined=user_defined,
         )
 
@@ -1014,6 +1112,7 @@ class ControlParameterOutput(ControlParameter):
         self,
         tooltip: str | list[dict] = "Connection to the next node in the execution chain",
         name: str = "exec_out",
+        display_name: str | None = "Flow Out",
         tooltip_as_input: str | list[dict] | None = None,
         tooltip_as_property: str | list[dict] | None = None,
         tooltip_as_output: str | list[dict] | None = None,
@@ -1026,6 +1125,11 @@ class ControlParameterOutput(ControlParameter):
         allowed_modes = {ParameterMode.OUTPUT}
         output_type = ParameterTypeBuiltin.CONTROL_TYPE.value
 
+        if display_name is None:
+            ui_options = None
+        else:
+            ui_options = {"display_name": display_name}
+
         # Call parent with a few explicit tweaks.
         super().__init__(
             name=name,
@@ -1039,6 +1143,7 @@ class ControlParameterOutput(ControlParameter):
             traits=traits,
             converters=converters,
             validators=validators,
+            ui_options=ui_options,
             user_defined=user_defined,
         )
 

griptape_nodes/exe_types/node_types.py

@@ -68,6 +68,7 @@ class BaseNode(ABC):
     _entry_control_parameter: Parameter | None = (
         None  # The control input parameter used to enter this node during execution
     )
+    lock: bool = False  # When lock is true, the node is locked and can't be modified. When lock is false, the node is unlocked and can be modified.
 
     @property
     def parameters(self) -> list[Parameter]:

griptape_nodes/machines/control_flow.py

@@ -88,11 +88,12 @@ class ResolveNodeState(State):
             return CompleteState
 
         # Mark the node unresolved, and broadcast an event to the GUI.
-        context.current_node.make_node_unresolved(
-            current_states_to_trigger_change_event=set(
-                {NodeResolutionState.UNRESOLVED, NodeResolutionState.RESOLVED, NodeResolutionState.RESOLVING}
+        if not context.current_node.lock:
+            context.current_node.make_node_unresolved(
+                current_states_to_trigger_change_event=set(
+                    {NodeResolutionState.UNRESOLVED, NodeResolutionState.RESOLVED, NodeResolutionState.RESOLVING}
+                )
             )
-        )
         # Now broadcast that we have a current control node.
         EventBus.publish_event(
             ExecutionGriptapeNodeEvent(

griptape_nodes/machines/node_resolution.py

@@ -195,10 +195,56 @@ class ExecuteNodeState(State):
             EventBus.publish_event(ExecutionGriptapeNodeEvent(wrapped_event=ExecutionEvent(payload=payload)))
         current_node.parameter_output_values.clear()
 
+    @staticmethod
+    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
+        connected upstream nodes, and if those nodes are resolved, retrieves their output
+        values and passes them through using SetParameterValueRequest.
+
+        Args:
+            context (ResolutionContext): The resolution context containing the focus stack
+                with the current node being processed.
+        """
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        current_node = context.focus_stack[-1].node
+        connections = GriptapeNodes.FlowManager().get_connections()
+
+        for parameter in current_node.parameters:
+            # Skip control type parameters
+            if ParameterTypeBuiltin.CONTROL_TYPE.value.lower() == parameter.output_type:
+                continue
+
+            # Get the connected upstream node for this parameter
+            upstream_connection = connections.get_connected_node(current_node, parameter)
+            if upstream_connection:
+                upstream_node, upstream_parameter = upstream_connection
+
+                # If the upstream node is resolved, collect its output value
+                if upstream_parameter.name in upstream_node.parameter_output_values:
+                    output_value = upstream_node.parameter_output_values[upstream_parameter.name]
+
+                    # Pass the value through using the same mechanism as normal resolution
+                    GriptapeNodes.get_instance().handle_request(
+                        SetParameterValueRequest(
+                            parameter_name=parameter.name,
+                            node_name=current_node.name,
+                            value=output_value,
+                            data_type=upstream_parameter.output_type,
+                        )
+                    )
+
     @staticmethod
     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)
         for parameter in current_node.parameters:
             if ParameterTypeBuiltin.CONTROL_TYPE.value.lower() == parameter.output_type:
@@ -244,95 +290,85 @@ class ExecuteNodeState(State):
         # Once everything has been set
         current_focus = context.focus_stack[-1]
         current_node = current_focus.node
-        # To set the event manager without circular import errors
-        EventBus.publish_event(
-            ExecutionGriptapeNodeEvent(
-                wrapped_event=ExecutionEvent(payload=NodeStartProcessEvent(node_name=current_node.name))
-            )
-        )
-        logger.info("Node '%s' is processing.", current_node.name)
-
-        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
-        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}"
-            # Mark the node as unresolved, broadcasting to everyone.
-            current_node.make_node_unresolved(
-                current_states_to_trigger_change_event=set(
-                    {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()
-
+        # 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(
                 ExecutionGriptapeNodeEvent(
-                    wrapped_event=ExecutionEvent(payload=NodeFinishProcessEvent(node_name=current_node.name))
+                    wrapped_event=ExecutionEvent(payload=NodeStartProcessEvent(node_name=current_node.name))
                 )
             )
-            raise RuntimeError(msg) from e
+            logger.info("Node '%s' is processing.", current_node.name)
 
-        logger.info("Node '%s' finished processing.", current_node.name)
+            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
+            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}"
+                # Mark the node as unresolved, broadcasting to everyone.
+                current_node.make_node_unresolved(
+                    current_states_to_trigger_change_event=set(
+                        {NodeResolutionState.UNRESOLVED, NodeResolutionState.RESOLVED, NodeResolutionState.RESOLVING}
+                    )
+                )
+                current_focus.process_generator = None
+                current_focus.scheduled_value = None
 
-        EventBus.publish_event(
-            ExecutionGriptapeNodeEvent(
-                wrapped_event=ExecutionEvent(payload=NodeFinishProcessEvent(node_name=current_node.name))
-            )
-        )
-        current_node.state = NodeResolutionState.RESOLVED
-        details = f"'{current_node.name}' resolved."
+                from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
-        logger.info(details)
+                GriptapeNodes.FlowManager().cancel_flow_run()
 
-        # Serialization can be slow so only do it if the user wants debug details.
-        if logger.level <= logging.DEBUG:
-            logger.debug(
-                "INPUTS: %s\nOUTPUTS: %s",
-                TypeValidator.safe_serialize(current_node.parameter_values),
-                TypeValidator.safe_serialize(current_node.parameter_output_values),
-            )
+                EventBus.publish_event(
+                    ExecutionGriptapeNodeEvent(
+                        wrapped_event=ExecutionEvent(payload=NodeFinishProcessEvent(node_name=current_node.name))
+                    )
+                )
+                raise RuntimeError(msg) from e
+
+            logger.info("Node '%s' finished processing.", current_node.name)
 
-        for parameter_name, value in current_node.parameter_output_values.items():
-            parameter = current_node.get_parameter_by_name(parameter_name)
-            if parameter is None:
-                err = f"Canceling flow run. Node '{current_node.name}' specified a Parameter '{parameter_name}', but no such Parameter could be found on that Node."
-                raise KeyError(err)
-            data_type = parameter.type
-            if data_type is None:
-                data_type = ParameterTypeBuiltin.NONE.value
             EventBus.publish_event(
                 ExecutionGriptapeNodeEvent(
-                    wrapped_event=ExecutionEvent(
-                        payload=ParameterValueUpdateEvent(
-                            node_name=current_node.name,
-                            parameter_name=parameter_name,
-                            data_type=data_type,
-                            value=TypeValidator.safe_serialize(value),
-                        )
-                    ),
+                    wrapped_event=ExecutionEvent(payload=NodeFinishProcessEvent(node_name=current_node.name))
                 )
             )
-            # Pass the value through to the new nodes.
-            conn_output_nodes = GriptapeNodes.FlowManager().get_connected_output_parameters(current_node, parameter)
-            for target_node, target_parameter in conn_output_nodes:
-                GriptapeNodes.get_instance().handle_request(
-                    SetParameterValueRequest(
-                        parameter_name=target_parameter.name,
-                        node_name=target_node.name,
-                        value=value,
-                        data_type=parameter.output_type,
-                    )
+            current_node.state = NodeResolutionState.RESOLVED
+            details = f"'{current_node.name}' resolved."
+
+            logger.info(details)
+
+            # Serialization can be slow so only do it if the user wants debug details.
+            if logger.level <= logging.DEBUG:
+                logger.debug(
+                    "INPUTS: %s\nOUTPUTS: %s",
+                    TypeValidator.safe_serialize(current_node.parameter_values),
+                    TypeValidator.safe_serialize(current_node.parameter_output_values),
                 )
 
-        # Output values should already be saved!
+            for parameter_name, value in current_node.parameter_output_values.items():
+                parameter = current_node.get_parameter_by_name(parameter_name)
+                if parameter is None:
+                    err = f"Canceling flow run. Node '{current_node.name}' specified a Parameter '{parameter_name}', but no such Parameter could be found on that Node."
+                    raise KeyError(err)
+                data_type = parameter.type
+                if data_type is None:
+                    data_type = ParameterTypeBuiltin.NONE.value
+                EventBus.publish_event(
+                    ExecutionGriptapeNodeEvent(
+                        wrapped_event=ExecutionEvent(
+                            payload=ParameterValueUpdateEvent(
+                                node_name=current_node.name,
+                                parameter_name=parameter_name,
+                                data_type=data_type,
+                                value=TypeValidator.safe_serialize(value),
+                            )
+                        ),
+                    )
+                )
+            # Output values should already be saved!
         library = LibraryRegistry.get_libraries_with_node_type(current_node.__class__.__name__)
         if len(library) == 1:
             library_name = library[0]

griptape_nodes/mcp_server/server.py

@@ -57,19 +57,21 @@ SUPPORTED_REQUEST_EVENTS: dict[str, type[RequestPayload]] = {
     "SetParameterValueRequest": SetParameterValueRequest,
 }
 
+GTN_MCP_SERVER_HOST = os.getenv("GTN_MCP_SERVER_HOST", "localhost")
 GTN_MCP_SERVER_PORT = int(os.getenv("GTN_MCP_SERVER_PORT", "9927"))
+GTN_MCP_SERVER_LOG_LEVEL = os.getenv("GTN_MCP_SERVER_LOG_LEVEL", "ERROR").lower()
 
 config_manager = ConfigManager()
 secrets_manager = SecretsManager(config_manager)
 
+mcp_server_logger = logging.getLogger("griptape_nodes_mcp_server")
+mcp_server_logger.addHandler(RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True))
+mcp_server_logger.setLevel(logging.INFO)
+
 
 def main(api_key: str) -> None:
     """Main entry point for the Griptape Nodes MCP server."""
-    mcp_server_logger = logging.getLogger("griptape_nodes_mcp_server")
-    mcp_server_logger.addHandler(RichHandler(show_time=True, show_path=False, markup=True, rich_tracebacks=True))
-    mcp_server_logger.setLevel(logging.INFO)
-    mcp_server_logger.info("Starting MCP GTN server...")
-
+    mcp_server_logger.debug("Starting MCP GTN server...")
     # Give these a session ID
     connection_manager = WebSocketConnectionManager()
     request_manager = AsyncRequestManager(connection_manager, api_key)
@@ -108,11 +110,11 @@ def main(api_key: str) -> None:
     async def lifespan(_: FastAPI) -> AsyncIterator[None]:
         """Context manager for managing session manager lifecycle."""
         async with session_manager.run():
-            mcp_server_logger.info("GTN MCP server started with StreamableHTTP session manager!")
+            mcp_server_logger.debug("GTN MCP server started with StreamableHTTP session manager!")
             try:
                 yield
             finally:
-                mcp_server_logger.info("GTN MCP server shutting down...")
+                mcp_server_logger.debug("GTN MCP server shutting down...")
 
     # Create an ASGI application using the transport
     mcp_server_app = FastAPI(lifespan=lifespan)
@@ -123,4 +125,10 @@ def main(api_key: str) -> None:
 
     mcp_server_app.mount("/mcp", app=handle_streamable_http)
 
-    uvicorn.run(mcp_server_app, host="127.0.0.1", port=GTN_MCP_SERVER_PORT)
+    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,
+    )

griptape_nodes/retained_mode/events/app_events.py

@@ -18,15 +18,9 @@ class AppStartSessionRequest(RequestPayload):
     Use when: Initializing client connections, beginning new workflow sessions,
     setting up isolated execution environments, managing session state.
 
-    Args:
-        session_id: Specific session ID to use (None for auto-generated)
-
     Results: AppStartSessionResultSuccess (with session ID) | AppStartSessionResultFailure (session creation error)
     """
 
-    # TODO: https://github.com/griptape-ai/griptape-nodes/issues/1600
-    session_id: str | None = None
-
 
 @dataclass
 @PayloadRegistry.register

griptape_nodes/retained_mode/events/base_events.py

@@ -10,7 +10,7 @@ from griptape.events import BaseEvent as GtBaseEvent
 from griptape.mixins.serializable_mixin import SerializableMixin
 from griptape.structures import Structure
 from griptape.tools import BaseTool
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 if TYPE_CHECKING:
     import builtins
@@ -118,16 +118,15 @@ class BaseEvent(BaseModel, ABC):
     session_id: str | None = Field(default_factory=lambda: BaseEvent._session_id)
 
     # Custom JSON encoder for the payload
-    class Config:
-        """Pydantic configuration for the BaseEvent class."""
-
-        arbitrary_types_allowed = True
-        json_encoders: ClassVar[dict] = {
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        json_encoders={
             # Use to_dict() methods for Griptape objects
             BaseArtifact: lambda obj: obj.to_dict(),
             BaseTool: lambda obj: obj.to_dict(),
             Structure: lambda obj: obj.to_dict(),
-        }
+        },
+    )
 
     def dict(self, *args, **kwargs) -> dict[str, Any]:
         """Override dict to handle payload serialization and add event_type."""

griptape_nodes/retained_mode/events/flow_events.py

@@ -9,7 +9,7 @@ from griptape_nodes.retained_mode.events.base_events import (
     WorkflowAlteredMixin,
     WorkflowNotAlteredMixin,
 )
-from griptape_nodes.retained_mode.events.node_events import SerializedNodeCommands
+from griptape_nodes.retained_mode.events.node_events import SerializedNodeCommands, SetLockNodeStateRequest
 from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
 from griptape_nodes.retained_mode.events.workflow_events import ImportWorkflowAsReferencedSubFlowRequest
 
@@ -229,6 +229,7 @@ class SerializedFlowCommands:
     set_parameter_value_commands: dict[
         SerializedNodeCommands.NodeUUID, list[SerializedNodeCommands.IndirectSetParameterValueCommand]
     ]
+    set_lock_commands_per_node: dict[SerializedNodeCommands.NodeUUID, SetLockNodeStateRequest]
     sub_flows_commands: list["SerializedFlowCommands"]
     referenced_workflows: set[str]