griptape-nodes 0.37.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

griptape_nodes/retained_mode/griptape_nodes.py

@@ -58,6 +58,9 @@ if TYPE_CHECKING:
     from griptape_nodes.retained_mode.managers.static_files_manager import (
         StaticFilesManager,
     )
+    from griptape_nodes.retained_mode.managers.version_compatibility_manager import (
+        VersionCompatibilityManager,
+    )
     from griptape_nodes.retained_mode.managers.workflow_manager import WorkflowManager
 
 
@@ -84,6 +87,26 @@ class Version:
     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)
+
 
 class GriptapeNodes(metaclass=SingletonMeta):
     _event_manager: EventManager
@@ -100,6 +123,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
     _operation_depth_manager: OperationDepthManager
     _static_files_manager: StaticFilesManager
     _agent_manager: AgentManager
+    _version_compatibility_manager: VersionCompatibilityManager
 
     def __init__(self) -> None:
         from griptape_nodes.retained_mode.managers.agent_manager import AgentManager
@@ -121,6 +145,9 @@ class GriptapeNodes(metaclass=SingletonMeta):
         from griptape_nodes.retained_mode.managers.static_files_manager import (
             StaticFilesManager,
         )
+        from griptape_nodes.retained_mode.managers.version_compatibility_manager import (
+            VersionCompatibilityManager,
+        )
         from griptape_nodes.retained_mode.managers.workflow_manager import (
             WorkflowManager,
         )
@@ -143,6 +170,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
                 self._config_manager, self._secrets_manager, self._event_manager
             )
             self._agent_manager = AgentManager(self._event_manager)
+            self._version_compatibility_manager = VersionCompatibilityManager(self._event_manager)
 
             # Assign handlers now that these are created.
             self._event_manager.assign_manager_to_request_type(
@@ -230,6 +258,10 @@ class GriptapeNodes(metaclass=SingletonMeta):
     def AgentManager(cls) -> AgentManager:
         return GriptapeNodes.get_instance()._agent_manager
 
+    @classmethod
+    def VersionCompatibilityManager(cls) -> VersionCompatibilityManager:
+        return GriptapeNodes.get_instance()._version_compatibility_manager
+
     @classmethod
     def clear_data(cls) -> None:
         # Get canvas

griptape_nodes/retained_mode/managers/agent_manager.py

@@ -1,11 +1,13 @@
 import logging
 
-from griptape.artifacts import ErrorArtifact
+from griptape.artifacts import ErrorArtifact, TextArtifact
 from griptape.drivers.prompt.griptape_cloud import GriptapeCloudPromptDriver
+from griptape.events import EventBus, FinishTaskEvent, TextChunkEvent
 from griptape.memory.structure import ConversationMemory
-from griptape.tasks import PromptTask
+from griptape.structures import Agent
 
 from griptape_nodes.retained_mode.events.agent_events import (
+    AgentStreamEvent,
     ConfigureAgentRequest,
     ConfigureAgentResultFailure,
     ConfigureAgentResultSuccess,
@@ -19,7 +21,7 @@ from griptape_nodes.retained_mode.events.agent_events import (
     RunAgentResultFailure,
     RunAgentResultSuccess,
 )
-from griptape_nodes.retained_mode.events.base_events import ResultPayload
+from griptape_nodes.retained_mode.events.base_events import ExecutionEvent, ExecutionGriptapeNodeEvent, ResultPayload
 from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
 from griptape_nodes.retained_mode.managers.event_manager import EventManager
 from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
@@ -53,21 +55,32 @@ class AgentManager:
         if not api_key:
             msg = f"Secret '{API_KEY_ENV_VAR}' not found"
             raise ValueError(msg)
-        return GriptapeCloudPromptDriver(api_key=api_key)
+        return GriptapeCloudPromptDriver(api_key=api_key, stream=True)
 
     def on_handle_run_agent_request(self, request: RunAgentRequest) -> ResultPayload:
         try:
             if self.prompt_driver is None:
                 self.prompt_driver = self._initialize_prompt_driver()
-            task_output = PromptTask(
-                request.input, prompt_driver=self.prompt_driver, conversation_memory=self.conversation_memory
-            ).run()
-            if isinstance(task_output, ErrorArtifact):
-                details = f"Error running agent: {task_output.value}"
-                logger.error(details)
-                return RunAgentResultFailure(error=task_output.to_json())
-            return RunAgentResultSuccess(output=task_output.to_json())
+            agent = Agent(prompt_driver=self.prompt_driver, conversation_memory=self.conversation_memory)
+            *events, last_event = agent.run_stream(request.input)
+            for event in events:
+                if isinstance(event, TextChunkEvent):
+                    EventBus.publish_event(
+                        ExecutionGriptapeNodeEvent(
+                            wrapped_event=ExecutionEvent(payload=AgentStreamEvent(token=event.token))
+                        )
+                    )
+            if isinstance(last_event, FinishTaskEvent):
+                if isinstance(last_event.task_output, ErrorArtifact):
+                    return RunAgentResultFailure(last_event.task_output.to_json())
+                if isinstance(last_event.task_output, TextArtifact):
+                    return RunAgentResultSuccess(last_event.task_output.to_json())
+            err_msg = f"Unexpected final event: {last_event}"
+            logger.error(err_msg)
+            return RunAgentResultFailure(ErrorArtifact(last_event).to_json())
         except Exception as e:
+            err_msg = f"Error running agent: {e}"
+            logger.error(err_msg)
             return RunAgentResultFailure(ErrorArtifact(e).to_json())
 
     def on_handle_configure_agent_request(self, request: ConfigureAgentRequest) -> ResultPayload:

griptape_nodes/retained_mode/managers/config_manager.py

@@ -1,6 +1,7 @@
 import copy
 import json
 import logging
+import os
 from pathlib import Path
 from typing import Any, Literal
 
@@ -40,9 +41,14 @@ USER_CONFIG_PATH = xdg_config_home() / "griptape_nodes" / "griptape_nodes_config
 class ConfigManager:
     """A class to manage application configuration and file pathing.
 
-    This class handles loading and saving configuration from a config.json file
-    located in the project root. If the config file is not found, it will create
-    one with default values.
+    This class handles loading and saving configuration from multiple sources with the following precedence:
+    1. Default configuration from Settings model (lowest priority)
+    2. User global configuration from ~/.config/griptape_nodes/griptape_nodes_config.json
+    3. Workspace-specific configuration from <workspace>/griptape_nodes_config.json
+    4. Environment variables with GTN_CONFIG_ prefix (highest priority)
+
+    Environment variables starting with GTN_CONFIG_ are converted to config keys by removing the prefix
+    and converting to lowercase (e.g., GTN_CONFIG_FOO=bar becomes {"foo": "bar"}).
 
     Supports categorized configuration using dot notation (e.g., 'category.subcategory.key')
     to organize related configuration items.
@@ -51,7 +57,8 @@ class ConfigManager:
         default_config (dict): The default configuration loaded from the Settings model.
         user_config (dict): The user configuration loaded from the config file.
         workspace_config (dict): The workspace configuration loaded from the workspace config file.
-        merged_config (dict): The merged configuration, combining default, user, and workspace settings.
+        env_config (dict): The configuration loaded from GTN_CONFIG_ environment variables.
+        merged_config (dict): The merged configuration, combining all sources in precedence order.
     """
 
     def __init__(self, event_manager: EventManager | None = None) -> None:
@@ -126,6 +133,26 @@ class ConfigManager:
 
         return [config_file for config_file in possible_config_files if config_file.exists()]
 
+    def _load_config_from_env_vars(self) -> dict[str, Any]:
+        """Load configuration values from GTN_CONFIG_ environment variables.
+
+        Environment variables starting with GTN_CONFIG_ are converted to config keys.
+        GTN_CONFIG_FOO=bar becomes {"foo": "bar"}
+        GTN_CONFIG_STORAGE_BACKEND=gtc becomes {"storage_backend": "gtc"}
+
+        Returns:
+            Dictionary containing config values from environment variables
+        """
+        env_config = {}
+        for key, value in os.environ.items():
+            if key.startswith("GTN_CONFIG_"):
+                # Remove GTN_CONFIG_ prefix and convert to lowercase
+                config_key = key[11:].lower()  # len("GTN_CONFIG_") = 11
+                env_config[config_key] = value
+                logger.debug("Loaded config from env var: %s -> %s", key, config_key)
+
+        return env_config
+
     def load_configs(self) -> None:
         """Load configs from the user config file and the workspace config file.
 
@@ -159,6 +186,12 @@ class ConfigManager:
             self.workspace_config = {}
             logger.debug("Workspace config file not found")
 
+        # Merge in configuration from GTN_CONFIG_ environment variables (highest priority)
+        self.env_config = self._load_config_from_env_vars()
+        if self.env_config:
+            merged_config = merge_dicts(merged_config, self.env_config)
+            logger.debug("Merged config from environment variables: %s", list(self.env_config.keys()))
+
         # Validate the full config against the Settings model.
         try:
             Settings.model_validate(merged_config)

griptape_nodes/retained_mode/managers/event_manager.py

@@ -8,11 +8,14 @@ from typing_extensions import TypeVar
 
 from griptape_nodes.retained_mode.events.base_events import (
     AppPayload,
+    EventRequest,
     EventResultFailure,
     EventResultSuccess,
+    FlushParameterChangesRequest,
     GriptapeNodeEvent,
     RequestPayload,
     ResultPayload,
+    WorkflowAlteredMixin,
 )
 
 if TYPE_CHECKING:
@@ -30,6 +33,11 @@ class EventManager:
         # Dictionary to store ALL SUBSCRIBERS to app events.
         self._app_event_listeners: dict[type[AppPayload], set[Callable]] = {}
         self.current_active_node: str | None = None
+        # Boolean that lets us know if there is currently a FlushParameterChangesRequest in the event queue.
+        self._flush_in_queue: bool = False
+
+    def clear_flush_in_queue(self) -> None:
+        self._flush_in_queue = False
 
     def assign_manager_to_request_type(
         self,
@@ -96,6 +104,13 @@ class EventManager:
                         result=result_payload,
                         retained_mode=retained_mode_str,
                     )
+                    # If the result is a success, and the WorkflowAlteredMixin is present, that means the flow has been changed in some way.
+                    # In that case, we need to flush the element changes, so we add one to the event queue.
+                    if isinstance(result_event.result, WorkflowAlteredMixin) and not self._flush_in_queue:
+                        from griptape_nodes.app.app import event_queue
+
+                        event_queue.put(EventRequest(request=FlushParameterChangesRequest()))
+                        self._flush_in_queue = True
                 else:
                     result_event = EventResultFailure(
                         request=request,

griptape_nodes/retained_mode/managers/flow_manager.py

@@ -3,15 +3,16 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, cast
 
-from griptape.events import EventBus
-
 from griptape_nodes.exe_types.core_types import (
     ParameterContainer,
     ParameterMode,
 )
 from griptape_nodes.exe_types.flow import ControlFlow
 from griptape_nodes.exe_types.node_types import BaseNode, NodeResolutionState
-from griptape_nodes.retained_mode.events.base_events import ExecutionEvent, ExecutionGriptapeNodeEvent
+from griptape_nodes.retained_mode.events.base_events import (
+    FlushParameterChangesRequest,
+    FlushParameterChangesResultSuccess,
+)
 from griptape_nodes.retained_mode.events.connection_events import (
     CreateConnectionRequest,
     CreateConnectionResultFailure,
@@ -81,7 +82,6 @@ from griptape_nodes.retained_mode.events.node_events import (
     SerializeNodeToCommandsResultSuccess,
 )
 from griptape_nodes.retained_mode.events.parameter_events import (
-    AlterElementEvent,
     SetParameterValueRequest,
 )
 from griptape_nodes.retained_mode.events.validation_events import (
@@ -130,6 +130,7 @@ class FlowManager:
         event_manager.assign_manager_to_request_type(
             DeserializeFlowFromCommandsRequest, self.on_deserialize_flow_from_commands
         )
+        event_manager.assign_manager_to_request_type(FlushParameterChangesRequest, self.on_flush_request)
 
         self._name_to_parent_name = {}
 
@@ -607,37 +608,32 @@ class FlowManager:
             return CreateConnectionResultFailure()
 
         # Let the source make any internal handling decisions now that the Connection has been made.
-        modified_source_parameters = set()
-        source_node.after_outgoing_connection(
-            source_parameter=source_param,
-            target_node=target_node,
-            target_parameter=target_param,
-            modified_parameters_set=modified_source_parameters,
-        )
+        try:
+            source_node.after_outgoing_connection(
+                source_parameter=source_param, target_node=target_node, target_parameter=target_param
+            )
+        except TypeError:
+            source_node.after_outgoing_connection(
+                source_parameter=source_param,
+                target_node=target_node,
+                target_parameter=target_param,
+                modified_parameters_set=set(),
+            )
 
         # And target.
-        modified_target_parameters = set()
-        target_node.after_incoming_connection(
-            source_node=source_node,
-            source_parameter=source_param,
-            target_parameter=target_param,
-            modified_parameters_set=modified_target_parameters,
-        )
-
-        if modified_source_parameters:
-            for modified_parameter_name in modified_source_parameters:
-                # TODO: https://github.com/griptape-ai/griptape-nodes/issues/865
-                modified_parameter = source_node.get_parameter_by_name(modified_parameter_name)
-                if modified_parameter is not None:
-                    modified_request = AlterElementEvent(element_details=modified_parameter.to_event(source_node))
-                    EventBus.publish_event(ExecutionGriptapeNodeEvent(ExecutionEvent(payload=modified_request)))
-        if modified_target_parameters:
-            for modified_parameter_name in modified_target_parameters:
-                # TODO: https://github.com/griptape-ai/griptape-nodes/issues/865
-                modified_parameter = target_node.get_parameter_by_name(modified_parameter_name)
-                if modified_parameter is not None:
-                    modified_request = AlterElementEvent(element_details=modified_parameter.to_event(target_node))
-                    EventBus.publish_event(ExecutionGriptapeNodeEvent(ExecutionEvent(payload=modified_request)))
+        try:
+            target_node.after_incoming_connection(
+                source_node=source_node,
+                source_parameter=source_param,
+                target_parameter=target_param,
+            )
+        except TypeError:
+            target_node.after_incoming_connection(
+                source_node=source_node,
+                source_parameter=source_param,
+                target_parameter=target_param,
+                modified_parameters_set=set(),
+            )
 
         details = f'Connected "{source_node_name}.{request.source_parameter_name}" to "{target_node_name}.{request.target_parameter_name}"'
         logger.debug(details)
@@ -801,37 +797,33 @@ class FlowManager:
                 )
             except KeyError as e:
                 logger.warning(e)
-        modified_source_parameters = set()
         # Let the source make any internal handling decisions now that the Connection has been REMOVED.
-        source_node.after_outgoing_connection_removed(
-            source_parameter=source_param,
-            target_node=target_node,
-            target_parameter=target_param,
-            modified_parameters_set=modified_source_parameters,
-        )
+        try:
+            source_node.after_outgoing_connection_removed(
+                source_parameter=source_param, target_node=target_node, target_parameter=target_param
+            )
+        except TypeError:
+            source_node.after_outgoing_connection_removed(
+                source_parameter=source_param,
+                target_node=target_node,
+                target_parameter=target_param,
+                modified_parameters_set=set(),
+            )
 
         # And target.
-        modified_target_parameters = set()
-        target_node.after_incoming_connection_removed(
-            source_node=source_node,
-            source_parameter=source_param,
-            target_parameter=target_param,
-            modified_parameters_set=modified_target_parameters,
-        )
-        if modified_source_parameters:
-            for modified_parameter_name in modified_source_parameters:
-                # TODO: https://github.com/griptape-ai/griptape-nodes/issues/865
-                modified_parameter = source_node.get_parameter_by_name(modified_parameter_name)
-                if modified_parameter is not None:
-                    modified_request = AlterElementEvent(element_details=modified_parameter.to_event(source_node))
-                    EventBus.publish_event(ExecutionGriptapeNodeEvent(ExecutionEvent(payload=modified_request)))
-        if modified_target_parameters:
-            for modified_parameter_name in modified_target_parameters:
-                # TODO: https://github.com/griptape-ai/griptape-nodes/issues/865
-                modified_parameter = target_node.get_parameter_by_name(modified_parameter_name)
-                if modified_parameter is not None:
-                    modified_request = AlterElementEvent(element_details=modified_parameter.to_event(target_node))
-                    EventBus.publish_event(ExecutionGriptapeNodeEvent(ExecutionEvent(payload=modified_request)))
+        try:
+            target_node.after_incoming_connection_removed(
+                source_node=source_node,
+                source_parameter=source_param,
+                target_parameter=target_param,
+            )
+        except TypeError:
+            target_node.after_incoming_connection_removed(
+                source_node=source_node,
+                source_parameter=source_param,
+                target_parameter=target_param,
+                modified_parameters_set=set(),
+            )
 
         details = f'Connection "{source_node_name}.{request.source_parameter_name}" to "{target_node_name}.{request.target_parameter_name}" deleted.'
         logger.debug(details)
@@ -1387,3 +1379,14 @@ class FlowManager:
         details = f"Successfully deserialized Flow '{flow_name}'."
         logger.debug(details)
         return DeserializeFlowFromCommandsResultSuccess(flow_name=flow_name)
+
+    def on_flush_request(self, request: FlushParameterChangesRequest) -> ResultPayload:  # noqa: ARG002
+        obj_manager = GriptapeNodes.ObjectManager()
+        GriptapeNodes.EventManager().clear_flush_in_queue()
+        # Get all flows and their nodes
+        nodes = obj_manager.get_filtered_subset(type=BaseNode)
+        for node in nodes.values():
+            # Only flush if there are actually tracked parameters
+            if node._tracked_parameters:
+                node.emit_parameter_changes()
+        return FlushParameterChangesResultSuccess()