griptape-nodes 0.57.1__py3-none-any.whl → 0.58.1__py3-none-any.whl

griptape_nodes/retained_mode/events/node_events.py

@@ -1,10 +1,21 @@
+from __future__ import annotations
+
 from dataclasses import dataclass, field
 from enum import Enum, auto
-from typing import Any, NamedTuple, NewType
+from typing import TYPE_CHECKING, Any, NamedTuple, NewType
 from uuid import uuid4
 
-from griptape_nodes.exe_types.core_types import NodeMessagePayload
-from griptape_nodes.exe_types.node_types import NodeDependencies, NodeResolutionState
+from griptape_nodes.exe_types.node_types import NodeResolutionState
+
+if TYPE_CHECKING:
+    from griptape_nodes.exe_types.core_types import NodeMessagePayload
+    from griptape_nodes.exe_types.node_types import NodeDependencies
+    from griptape_nodes.retained_mode.events.connection_events import ListConnectionsForNodeResultSuccess
+    from griptape_nodes.retained_mode.events.parameter_events import (
+        GetParameterDetailsResultSuccess,
+        GetParameterValueResultSuccess,
+        SetParameterValueRequest,
+    )
 from griptape_nodes.retained_mode.events.base_events import (
     RequestPayload,
     ResultPayloadFailure,
@@ -12,12 +23,6 @@ from griptape_nodes.retained_mode.events.base_events import (
     WorkflowAlteredMixin,
     WorkflowNotAlteredMixin,
 )
-from griptape_nodes.retained_mode.events.connection_events import ListConnectionsForNodeResultSuccess
-from griptape_nodes.retained_mode.events.parameter_events import (
-    GetParameterDetailsResultSuccess,
-    GetParameterValueResultSuccess,
-    SetParameterValueRequest,
-)
 from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
 
 
@@ -430,7 +435,7 @@ class SerializedNodeCommands:
         """
 
         set_parameter_value_command: SetParameterValueRequest
-        unique_value_uuid: "SerializedNodeCommands.UniqueParameterValueUUID"
+        unique_value_uuid: SerializedNodeCommands.UniqueParameterValueUUID
 
     create_node_command: CreateNodeRequest
     element_modification_commands: list[RequestPayload]
@@ -573,12 +578,14 @@ class SerializeSelectedNodesToCommandsRequest(WorkflowNotAlteredMixin, RequestPa
 
     Args:
         nodes_to_serialize: List of node identifiers (each containing [node_name, timestamp])
+        copy_to_clipboard: Whether to copy the result to clipboard (defaults to True for backward compatibility)
 
     Results: SerializeSelectedNodesToCommandsResultSuccess (with commands) | SerializeSelectedNodesToCommandsResultFailure (node not found, serialization error)
     """
 
     # They will be passed with node_name, timestamp
     nodes_to_serialize: list[list[str]]
+    copy_to_clipboard: bool = True
 
 
 @dataclass

griptape_nodes/retained_mode/events/workflow_events.py

@@ -278,12 +278,14 @@ class SaveWorkflowRequest(RequestPayload):
     Args:
         file_name: Name of the file to save the workflow to (None for auto-generated)
         image_path: Path to save workflow image/thumbnail (None for no image)
+        pickle_control_flow_result: Whether to use pickle-based serialization for control flow results (None for default behavior)
 
     Results: SaveWorkflowResultSuccess (with file path) | SaveWorkflowResultFailure (save error)
     """
 
     file_name: str | None = None
     image_path: str | None = None
+    pickle_control_flow_result: bool | None = None
 
 
 @dataclass
@@ -388,6 +390,7 @@ class PublishWorkflowRequest(RequestPayload):
     publisher_name: str
     execute_on_publish: bool = False
     published_workflow_file_name: str | None = None
+    pickle_control_flow_result: bool = False
 
 
 @dataclass
@@ -655,6 +658,7 @@ class SaveWorkflowFileFromSerializedFlowRequest(RequestPayload):
         branched_from: Optional branched from information to preserve workflow lineage
         workflow_shape: Optional workflow shape defining inputs and outputs for external callers
         file_path: Optional specific file path to use (defaults to workspace path if not provided)
+        pickle_control_flow_result: Whether to pickle control flow results in generated execution code (defaults to False)
 
     Results: SaveWorkflowFileFromSerializedFlowResultSuccess (with file path) | SaveWorkflowFileFromSerializedFlowResultFailure (save error)
     """
@@ -667,6 +671,7 @@ class SaveWorkflowFileFromSerializedFlowRequest(RequestPayload):
     execution_flow_name: str | None = None
     branched_from: str | None = None
     workflow_shape: WorkflowShape | None = None
+    pickle_control_flow_result: bool = False
 
 
 @dataclass

griptape_nodes/retained_mode/griptape_nodes.py

@@ -2,42 +2,23 @@ from __future__ import annotations
 
 import logging
 import os
-import re
-import uuid
-from dataclasses import dataclass
 from datetime import UTC, datetime
 from typing import TYPE_CHECKING, Any
 
+import semver
+
 from griptape_nodes.exe_types.flow import ControlFlow
 from griptape_nodes.node_library.workflow_registry import WorkflowRegistry
 from griptape_nodes.retained_mode.events.app_events import (
-    AppConnectionEstablished,
-    AppEndSessionRequest,
-    AppEndSessionResultFailure,
-    AppEndSessionResultSuccess,
-    AppGetSessionRequest,
-    AppGetSessionResultSuccess,
-    AppStartSessionRequest,
-    AppStartSessionResultSuccess,
     EngineHeartbeatRequest,
     EngineHeartbeatResultFailure,
     EngineHeartbeatResultSuccess,
-    GetEngineNameRequest,
-    GetEngineNameResultFailure,
-    GetEngineNameResultSuccess,
     GetEngineVersionRequest,
     GetEngineVersionResultFailure,
     GetEngineVersionResultSuccess,
-    SessionHeartbeatRequest,
-    SessionHeartbeatResultFailure,
-    SessionHeartbeatResultSuccess,
-    SetEngineNameRequest,
-    SetEngineNameResultFailure,
-    SetEngineNameResultSuccess,
 )
 from griptape_nodes.retained_mode.events.base_events import (
     GriptapeNodeEvent,
-    ResultDetails,
     ResultPayloadFailure,
 )
 from griptape_nodes.retained_mode.events.flow_events import (
@@ -89,48 +70,6 @@ if TYPE_CHECKING:
 logger = logging.getLogger("griptape_nodes")
 
 
-@dataclass
-class Version:
-    major: int
-    minor: int
-    patch: int
-
-    @classmethod
-    def from_string(cls, version_string: str) -> Version | None:
-        match = re.match(r"(\d+)\.(\d+)\.(\d+)", version_string)
-        if match:
-            major, minor, patch = map(int, match.groups())
-            return cls(major, minor, patch)
-        return None
-
-    def __str__(self) -> str:
-        return f"{self.major}.{self.minor}.{self.patch}"
-
-    def __lt__(self, other: Version) -> bool:
-        """Less than comparison."""
-        return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)
-
-    def __le__(self, other: Version) -> bool:
-        """Less than or equal comparison."""
-        return (self.major, self.minor, self.patch) <= (other.major, other.minor, other.patch)
-
-    def __gt__(self, other: Version) -> bool:
-        """Greater than comparison."""
-        return (self.major, self.minor, self.patch) > (other.major, other.minor, other.patch)
-
-    def __ge__(self, other: Version) -> bool:
-        """Greater than or equal comparison."""
-        return (self.major, self.minor, self.patch) >= (other.major, other.minor, other.patch)
-
-    def __eq__(self, other: Version) -> bool:  # type: ignore[override]
-        """Equality comparison."""
-        return (self.major, self.minor, self.patch) == (other.major, other.minor, other.patch)
-
-    def __hash__(self) -> int:
-        """Hash function for Version."""
-        return hash((self.major, self.minor, self.patch))
-
-
 class GriptapeNodes(metaclass=SingletonMeta):
     _event_manager: EventManager
     _os_manager: OSManager
@@ -155,7 +94,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
     _resource_manager: ResourceManager
     _sync_manager: SyncManager
 
-    def __init__(self) -> None:  # noqa: PLR0915
+    def __init__(self) -> None:
         from griptape_nodes.retained_mode.managers.agent_manager import AgentManager
         from griptape_nodes.retained_mode.managers.arbitrary_code_exec_manager import (
             ArbitraryCodeExecManager,
@@ -213,8 +152,8 @@ class GriptapeNodes(metaclass=SingletonMeta):
             )
             self._agent_manager = AgentManager(self._static_files_manager, self._event_manager)
             self._version_compatibility_manager = VersionCompatibilityManager(self._event_manager)
-            self._session_manager = SessionManager(self._event_manager)
             self._engine_identity_manager = EngineIdentityManager(self._event_manager)
+            self._session_manager = SessionManager(self._engine_identity_manager, self._event_manager)
             self._mcp_manager = MCPManager(self._event_manager, self._config_manager)
             self._sync_manager = SyncManager(self._event_manager, self._config_manager)
 
@@ -222,24 +161,9 @@ class GriptapeNodes(metaclass=SingletonMeta):
             self._event_manager.assign_manager_to_request_type(
                 GetEngineVersionRequest, self.handle_engine_version_request
             )
-            self._event_manager.assign_manager_to_request_type(
-                AppStartSessionRequest, self.handle_session_start_request
-            )
-            self._event_manager.assign_manager_to_request_type(AppEndSessionRequest, self.handle_session_end_request)
-            self._event_manager.add_listener_to_app_event(AppConnectionEstablished, self.on_app_connection_established)
-            self._event_manager.assign_manager_to_request_type(AppGetSessionRequest, self.handle_get_session_request)
-            self._event_manager.assign_manager_to_request_type(
-                SessionHeartbeatRequest, self.handle_session_heartbeat_request
-            )
             self._event_manager.assign_manager_to_request_type(
                 EngineHeartbeatRequest, self.handle_engine_heartbeat_request
             )
-            self._event_manager.assign_manager_to_request_type(
-                GetEngineNameRequest, self.handle_get_engine_name_request
-            )
-            self._event_manager.assign_manager_to_request_type(
-                SetEngineNameRequest, self.handle_set_engine_name_request
-            )
 
     @classmethod
     def get_instance(cls) -> GriptapeNodes:
@@ -304,11 +228,11 @@ class GriptapeNodes(metaclass=SingletonMeta):
 
     @classmethod
     def get_session_id(cls) -> str | None:
-        return GriptapeNodes.SessionManager().get_active_session_id()
+        return GriptapeNodes.SessionManager().active_session_id
 
     @classmethod
     def get_engine_id(cls) -> str | None:
-        return GriptapeNodes.EngineIdentityManager().get_active_engine_id()
+        return GriptapeNodes.EngineIdentityManager().active_engine_id
 
     @classmethod
     def EventManager(cls) -> EventManager:
@@ -421,113 +345,20 @@ class GriptapeNodes(metaclass=SingletonMeta):
             msg = "Failed to successfully delete all objects"
             raise ValueError(msg)
 
-    async def on_app_connection_established(self, _payload: AppConnectionEstablished) -> None:
-        from griptape_nodes.app.app import subscribe_to_topic
-
-        # Subscribe to request topic (engine discovery)
-        await subscribe_to_topic("request")
-
-        # Get engine ID and subscribe to engine_id/request
-        engine_id = GriptapeNodes.get_engine_id()
-        if engine_id:
-            await subscribe_to_topic(f"engines/{engine_id}/request")
-        else:
-            logger.warning("Engine ID not available for subscription")
-
-        # Get session ID and subscribe to session_id/request if available
-        session_id = GriptapeNodes.get_session_id()
-        if session_id:
-            topic = f"sessions/{session_id}/request"
-            await subscribe_to_topic(topic)
-        else:
-            logger.info("No session ID available for subscription")
-
     def handle_engine_version_request(self, request: GetEngineVersionRequest) -> ResultPayload:  # noqa: ARG002
         try:
-            engine_ver = Version.from_string(engine_version)
-            if engine_ver:
-                return GetEngineVersionResultSuccess(
-                    major=engine_ver.major,
-                    minor=engine_ver.minor,
-                    patch=engine_ver.patch,
-                    result_details="Engine version retrieved successfully.",
-                )
-            details = f"Attempted to get engine version. Failed because version string '{engine_ver}' wasn't in expected major.minor.patch format."
-            logger.error(details)
-            return GetEngineVersionResultFailure(result_details=details)
+            engine_ver = semver.VersionInfo.parse(engine_version)
+            return GetEngineVersionResultSuccess(
+                major=engine_ver.major,
+                minor=engine_ver.minor,
+                patch=engine_ver.patch,
+                result_details="Engine version retrieved successfully.",
+            )
         except Exception as err:
             details = f"Attempted to get engine version. Failed due to '{err}'."
             logger.error(details)
             return GetEngineVersionResultFailure(result_details=details)
 
-    async def handle_session_start_request(self, request: AppStartSessionRequest) -> ResultPayload:  # noqa: ARG002
-        from griptape_nodes.app.app import subscribe_to_topic
-
-        current_session_id = GriptapeNodes.SessionManager().get_active_session_id()
-        if current_session_id is None:
-            # Client wants a new session
-            current_session_id = uuid.uuid4().hex
-            GriptapeNodes.SessionManager().save_session(current_session_id)
-            details = f"New session '{current_session_id}' started at {datetime.now(tz=UTC)}."
-            logger.info(details)
-        else:
-            details = f"Session '{current_session_id}' already active. Joining..."
-
-        topic = f"sessions/{current_session_id}/request"
-        await subscribe_to_topic(topic)
-        logger.info("Subscribed to new session topic: %s", topic)
-
-        return AppStartSessionResultSuccess(current_session_id, result_details="Session started successfully.")
-
-    async def handle_session_end_request(self, _: AppEndSessionRequest) -> ResultPayload:
-        from griptape_nodes.app.app import unsubscribe_from_topic
-
-        try:
-            previous_session_id = GriptapeNodes.SessionManager().get_active_session_id()
-            if previous_session_id is None:
-                details = "No active session to end."
-                logger.info(details)
-            else:
-                details = f"Session '{previous_session_id}' ended at {datetime.now(tz=UTC)}."
-                logger.info(details)
-                GriptapeNodes.SessionManager().clear_saved_session()
-
-            unsubscribe_topic = f"sessions/{previous_session_id}/request"
-            await unsubscribe_from_topic(unsubscribe_topic)
-
-            return AppEndSessionResultSuccess(
-                session_id=previous_session_id, result_details="Session ended successfully."
-            )
-        except Exception as err:
-            details = f"Failed to end session due to '{err}'."
-            logger.error(details)
-            return AppEndSessionResultFailure(result_details=details)
-
-    def handle_get_session_request(self, _: AppGetSessionRequest) -> ResultPayload:
-        return AppGetSessionResultSuccess(
-            session_id=GriptapeNodes.SessionManager().get_active_session_id(),
-            result_details="Session ID retrieved successfully.",
-        )
-
-    def handle_session_heartbeat_request(self, request: SessionHeartbeatRequest) -> ResultPayload:  # noqa: ARG002
-        """Handle session heartbeat requests.
-
-        Simply verifies that the session is active and responds with success.
-        """
-        try:
-            active_session_id = GriptapeNodes.SessionManager().get_active_session_id()
-            if active_session_id is None:
-                details = "Session heartbeat received but no active session found"
-                logger.warning(details)
-                return SessionHeartbeatResultFailure(result_details=details)
-
-            details = f"Session heartbeat successful for session: {active_session_id}"
-            return SessionHeartbeatResultSuccess(result_details=details)
-        except Exception as err:
-            details = f"Failed to handle session heartbeat: {err}"
-            logger.error(details)
-            return SessionHeartbeatResultFailure(result_details=details)
-
     def handle_engine_heartbeat_request(self, request: EngineHeartbeatRequest) -> ResultPayload:
         """Handle engine heartbeat requests.
 
@@ -541,14 +372,14 @@ class GriptapeNodes(metaclass=SingletonMeta):
             workflow_info = self._get_current_workflow_info()
 
             # Get engine name
-            engine_name = GriptapeNodes.EngineIdentityManager().get_engine_name()
+            engine_name = GriptapeNodes.EngineIdentityManager().engine_name
 
             return EngineHeartbeatResultSuccess(
                 heartbeat_id=request.heartbeat_id,
                 engine_version=engine_version,
                 engine_name=engine_name,
-                engine_id=GriptapeNodes.EngineIdentityManager().get_active_engine_id(),
-                session_id=GriptapeNodes.SessionManager().get_active_session_id(),
+                engine_id=GriptapeNodes.EngineIdentityManager().active_engine_id,
+                session_id=GriptapeNodes.SessionManager().active_session_id,
                 timestamp=datetime.now(tz=UTC).isoformat(),
                 result_details="Engine heartbeat successful",
                 **instance_info,
@@ -559,40 +390,6 @@ class GriptapeNodes(metaclass=SingletonMeta):
             logger.error(details)
             return EngineHeartbeatResultFailure(heartbeat_id=request.heartbeat_id, result_details=details)
 
-    def handle_get_engine_name_request(self, request: GetEngineNameRequest) -> ResultPayload:  # noqa: ARG002
-        """Handle requests to get the current engine name."""
-        try:
-            engine_name = GriptapeNodes.EngineIdentityManager().get_engine_name()
-            return GetEngineNameResultSuccess(
-                engine_name=engine_name, result_details="Engine name retrieved successfully."
-            )
-        except Exception as err:
-            error_message = f"Failed to get engine name: {err}"
-            logger.error(error_message)
-            return GetEngineNameResultFailure(error_message=error_message, result_details=error_message)
-
-    def handle_set_engine_name_request(self, request: SetEngineNameRequest) -> ResultPayload:
-        """Handle requests to set a new engine name."""
-        try:
-            # Validate engine name (basic validation)
-            if not request.engine_name or not request.engine_name.strip():
-                error_message = "Engine name cannot be empty"
-                logger.warning(error_message)
-                return SetEngineNameResultFailure(error_message=error_message, result_details=error_message)
-
-            # Set the new engine name
-            GriptapeNodes.EngineIdentityManager().set_engine_name(request.engine_name.strip())
-            details = f"Engine name set to: {request.engine_name.strip()}"
-            return SetEngineNameResultSuccess(
-                engine_name=request.engine_name.strip(),
-                result_details=ResultDetails(message=details, level=logging.INFO),
-            )
-
-        except Exception as err:
-            error_message = f"Failed to set engine name: {err}"
-            logger.error(error_message)
-            return SetEngineNameResultFailure(error_message=error_message, result_details=error_message)
-
     def _get_instance_info(self) -> dict[str, str | None]:
         """Get instance information from environment variables.
 

griptape_nodes/retained_mode/managers/config_manager.py

@@ -9,7 +9,6 @@ from pydantic import ValidationError
 from xdg_base_dirs import xdg_config_home
 
 from griptape_nodes.node_library.library_registry import LibraryRegistry
-from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
 from griptape_nodes.retained_mode.events.base_events import ResultPayload
 from griptape_nodes.retained_mode.events.config_events import (
     GetConfigCategoryRequest,
@@ -91,11 +90,6 @@ class ConfigManager:
             )
             event_manager.assign_manager_to_request_type(ResetConfigRequest, self.on_handle_reset_config_request)
 
-            event_manager.add_listener_to_app_event(
-                AppInitializationComplete,
-                self.on_app_initialization_complete,
-            )
-
     @property
     def workspace_path(self) -> Path:
         """Get the base file path from the configuration.
@@ -231,34 +225,6 @@ class ConfigManager:
         )
         self.load_configs()
 
-    def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
-        # We want to ensure that all environment variables from here are pre-filled in the secrets manager.
-        env_var_names = self.gather_env_var_names()
-        for env_var_name in env_var_names:
-            self._update_secret_from_env_var(env_var_name)
-
-    def gather_env_var_names(self) -> list[str]:
-        """Gather all environment variable names within the config."""
-        return self._gather_env_var_names_in_dict(self.merged_config)
-
-    def _gather_env_var_names_in_dict(self, config: dict) -> list[str]:
-        """Gather all environment variable names from a given config dictionary."""
-        env_var_names = []
-        for value in config.values():
-            if isinstance(value, dict):
-                env_var_names.extend(self._gather_env_var_names_in_dict(value))
-            elif isinstance(value, str) and value.startswith("$"):
-                env_var_names.append(value[1:])
-        return env_var_names
-
-    def _update_secret_from_env_var(self, env_var_name: str) -> None:
-        # Lazy load to avoid circular import
-        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
-
-        if GriptapeNodes.SecretsManager().get_secret(env_var_name, should_error_on_not_found=False) is None:
-            # Set a blank one.
-            GriptapeNodes.SecretsManager().set_secret(env_var_name, "")
-
     def save_user_workflow_json(self, workflow_file_name: str) -> None:
         config_loc = "app_events.on_app_initialization_complete.workflows_to_register"
         existing_workflows = self.get_config_value(config_loc)
@@ -393,12 +359,6 @@ class ConfigManager:
 
         self.set_config_value(key=request.category, value=request.contents)
 
-        # Update any added env vars (this is dumb)
-        # TODO: https://github.com/griptape-ai/griptape-nodes/issues/1022
-        after_env_vars_set = set(self.gather_env_var_names())
-        for after_env_var in after_env_vars_set:
-            self._update_secret_from_env_var(after_env_var)
-
         result_details = f"Successfully assigned the config dictionary for section '{request.category}'."
         return SetConfigCategoryResultSuccess(result_details=result_details)
 
@@ -518,12 +478,6 @@ class ConfigManager:
         # Set the new value
         self.set_config_value(key=request.category_and_key, value=request.value)
 
-        # Update any added env vars (this is dumb)
-        # TODO: https://github.com/griptape-ai/griptape-nodes/issues/1022
-        after_env_vars_set = set(self.gather_env_var_names())
-        for after_env_var in after_env_vars_set:
-            self._update_secret_from_env_var(after_env_var)
-
         # For container types, indicate the change with a diff
         if isinstance(request.value, (dict, list)):
             if old_value_copy is not None: