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

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/node_library/workflow_registry.py

@@ -26,6 +26,7 @@ class WorkflowMetadata(BaseModel):
     is_template: bool | None = False
     creation_date: datetime | None = Field(default=None)
     last_modified_date: datetime | None = Field(default=None)
+    branched_from: str | None = Field(default=None)
 
 
 class WorkflowRegistry(metaclass=SingletonMeta):
@@ -81,6 +82,16 @@ class WorkflowRegistry(metaclass=SingletonMeta):
             raise KeyError(msg)
         return instance._workflows.pop(name)
 
+    @classmethod
+    def get_branches_of_workflow(cls, workflow_name: str) -> list[str]:
+        """Get all workflows that are branches of the specified workflow."""
+        instance = cls()
+        branches = []
+        for name, workflow in instance._workflows.items():
+            if workflow.metadata.branched_from == workflow_name:
+                branches.append(name)
+        return branches
+
 
 class Workflow:
     """A workflow card to be ran."""
@@ -102,6 +113,23 @@ class Workflow:
             msg = f"File path '{complete_path}' does not exist."
             raise ValueError(msg)
 
+    @property
+    def is_synced(self) -> bool:
+        """Check if this workflow is in the synced workflows directory."""
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+        config_mgr = GriptapeNodes.ConfigManager()
+        synced_directory = config_mgr.get_config_value("synced_workflows_directory")
+
+        # Get the full path to the synced workflows directory
+        synced_path = config_mgr.get_full_path(synced_directory)
+
+        # Get the complete file path for this workflow
+        complete_file_path = WorkflowRegistry.get_complete_file_path(self.file_path)
+
+        # Check if the workflow file is within the synced directory
+        return Path(complete_file_path).is_relative_to(synced_path)
+
     def get_workflow_metadata(self) -> dict:
         # Convert from the Pydantic schema.
         ret_val = {**self.metadata.model_dump()}
@@ -109,4 +137,5 @@ class Workflow:
         # The schema doesn't have the file path in it, because it is baked into the file itself.
         # Customers of this function need that, so let's stuff it in.
         ret_val["file_path"] = self.file_path
+        ret_val["is_synced"] = self.is_synced
         return ret_val

griptape_nodes/retained_mode/events/app_events.py

@@ -5,6 +5,7 @@ from griptape_nodes.retained_mode.events.base_events import (
     RequestPayload,
     ResultPayloadFailure,
     ResultPayloadSuccess,
+    SkipTheLineMixin,
     WorkflowNotAlteredMixin,
 )
 from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
@@ -18,15 +19,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
@@ -154,7 +149,7 @@ class AppEndSessionResultFailure(ResultPayloadFailure):
 
 @dataclass
 @PayloadRegistry.register
-class SessionHeartbeatRequest(RequestPayload):
+class SessionHeartbeatRequest(RequestPayload, SkipTheLineMixin):
     """Request clients can use ensure the engine session is still active."""
 
 
@@ -172,7 +167,7 @@ class SessionHeartbeatResultFailure(ResultPayloadFailure):
 
 @dataclass
 @PayloadRegistry.register
-class EngineHeartbeatRequest(RequestPayload):
+class EngineHeartbeatRequest(RequestPayload, SkipTheLineMixin):
     """Request clients can use to discover active engines and their status.
 
     Attributes:

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
@@ -62,6 +62,15 @@ class WorkflowNotAlteredMixin:
     altered_workflow_state: bool = field(default=False, init=False)
 
 
+class SkipTheLineMixin:
+    """Mixin for events that should skip the event queue and be processed immediately.
+
+    Events that implement this mixin will be handled directly without being added
+    to the event queue, allowing for priority processing of critical events like
+    heartbeats or other time-sensitive operations.
+    """
+
+
 # Success result payload abstract base class
 @dataclass(kw_only=True)
 class ResultPayloadSuccess(ResultPayload, ABC):
@@ -118,16 +127,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]
 

griptape_nodes/retained_mode/events/node_events.py

@@ -303,6 +303,7 @@ class GetAllNodeInfoResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess)
 
     metadata: dict
     node_resolution_state: str
+    locked: bool
     connections: ListConnectionsForNodeResultSuccess
     element_id_to_value: dict[str, ParameterInfoValue]
     root_node_element: dict[str, Any]
@@ -317,6 +318,39 @@ class GetAllNodeInfoResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure)
     """
 
 
+@dataclass
+@PayloadRegistry.register
+class SetLockNodeStateRequest(WorkflowNotAlteredMixin, RequestPayload):
+    """Lock a node.
+
+    Use when: Implementing locking functionality, preventing changes to nodes.
+
+    Args:
+        node_name: Name of the node to lock
+        lock: Whether to lock or unlock the node. If true, the node will be locked, otherwise it will be unlocked.
+
+    Results: SetLockNodeStateResultSuccess (node locked) | SetLockNodeStateResultFailure (node not found)
+    """
+
+    node_name: str | None
+    lock: bool
+
+
+@dataclass
+@PayloadRegistry.register
+class SetLockNodeStateResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Node locked successfully."""
+
+    node_name: str
+    locked: bool
+
+
+@dataclass
+@PayloadRegistry.register
+class SetLockNodeStateResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Node failed to lock."""
+
+
 # A Node's state can be serialized to a sequence of commands that the engine runs.
 @dataclass
 class SerializedNodeCommands:
@@ -354,6 +388,7 @@ class SerializedNodeCommands:
     create_node_command: CreateNodeRequest
     element_modification_commands: list[RequestPayload]
     node_library_details: LibraryNameAndVersion
+    lock_node_command: SetLockNodeStateRequest | None = None
     node_uuid: NodeUUID = field(default_factory=lambda: SerializedNodeCommands.NodeUUID(str(uuid4())))
 
 
@@ -477,6 +512,7 @@ class SerializedSelectedNodesCommands:
     set_parameter_value_commands: dict[
         SerializedNodeCommands.NodeUUID, list[SerializedNodeCommands.IndirectSetParameterValueCommand]
     ]
+    set_lock_commands_per_node: dict[SerializedNodeCommands.NodeUUID, SetLockNodeStateRequest]
     serialized_connection_commands: list[IndirectConnectionSerialization]