griptape-nodes 0.56.0__py3-none-any.whl → 0.57.0__py3-none-any.whl

griptape_nodes/exe_types/core_types.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import uuid
 from abc import ABC, abstractmethod
 from copy import deepcopy
@@ -9,6 +10,8 @@ from typing import TYPE_CHECKING, Any, ClassVar, Literal, NamedTuple, Self, Type
 
 from pydantic import BaseModel
 
+logger = logging.getLogger("griptape_nodes")
+
 
 class NodeMessagePayload(BaseModel):
     """Structured payload for node messages.
@@ -554,6 +557,7 @@ class ParameterMessage(BaseNodeElement, UIOptionsMixin):
         button_align: ButtonAlignType = "full-width",
         full_width: bool = False,
         ui_options: dict | None = None,
+        traits: set[Trait.__class__ | Trait] | None = None,
         **kwargs,
     ):
         super().__init__(element_type=ParameterMessage.__name__, **kwargs)
@@ -569,6 +573,17 @@ class ParameterMessage(BaseNodeElement, UIOptionsMixin):
         self._full_width = full_width
         self._ui_options = ui_options or {}
 
+        # Handle traits if provided
+        if traits:
+            for trait in traits:
+                if isinstance(trait, type):
+                    # It's a trait class, instantiate it
+                    trait_instance = trait()
+                else:
+                    # It's already a trait instance
+                    trait_instance = trait
+                self.add_child(trait_instance)
+
     @property
     def variant(self) -> VariantType:
         return self._variant
@@ -694,6 +709,16 @@ class ParameterMessage(BaseNodeElement, UIOptionsMixin):
         else:
             button_icon = self.button_icon
 
+        # Check if there are any Button traits with on_click callbacks
+        has_button_callback = False
+        for child in self.children:
+            # Import here to avoid circular imports
+            from griptape_nodes.traits.button import Button
+
+            if isinstance(child, Button) and child.on_click_callback is not None:
+                has_button_callback = True
+                break
+
         # Merge the UI options with the message-specific options
         # Always include these fields, even if they're None or empty
         message_ui_options = {
@@ -705,6 +730,7 @@ class ParameterMessage(BaseNodeElement, UIOptionsMixin):
             "button_icon": button_icon,
             "button_variant": self.button_variant,
             "button_align": self.button_align,
+            "button_on_click": has_button_callback,
             "full_width": self.full_width,
         }
 

griptape_nodes/exe_types/node_types.py

@@ -5,8 +5,9 @@ import logging
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Generator, Iterable
 from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass, field
 from enum import StrEnum, auto
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any, NamedTuple, TypeVar
 
 from griptape_nodes.exe_types.core_types import (
     BaseNodeElement,
@@ -43,6 +44,7 @@ from griptape_nodes.traits.options import Options
 
 if TYPE_CHECKING:
     from griptape_nodes.exe_types.core_types import NodeMessagePayload
+    from griptape_nodes.node_library.library_registry import LibraryNameAndVersion
 
 logger = logging.getLogger("griptape_nodes")
 
@@ -50,6 +52,53 @@ T = TypeVar("T")
 
 AsyncResult = Generator[Callable[[], T], T]
 
+LOCAL_EXECUTION = "Local Execution"
+
+
+class ImportDependency(NamedTuple):
+    """Import dependency specification for a node.
+
+    Attributes:
+        module: The module name to import
+        class_name: Optional class name to import from the module. If None, imports the entire module.
+    """
+
+    module: str
+    class_name: str | None = None
+
+
+@dataclass
+class NodeDependencies:
+    """Dependencies that a node has on external resources.
+
+    This class provides a way for nodes to declare their dependencies on workflows,
+    static files, Python imports, and libraries. This information can be used by the system
+    for workflow packaging, dependency resolution, and deployment planning.
+
+    Attributes:
+        referenced_workflows: Set of workflow names that this node references
+        static_files: Set of static file names that this node depends on
+        imports: Set of Python imports that this node requires
+        libraries: Set of library names and versions that this node uses
+    """
+
+    referenced_workflows: set[str] = field(default_factory=set)
+    static_files: set[str] = field(default_factory=set)
+    imports: set[ImportDependency] = field(default_factory=set)
+    libraries: set[LibraryNameAndVersion] = field(default_factory=set)
+
+    def aggregate_from(self, other: NodeDependencies) -> None:
+        """Aggregate dependencies from another NodeDependencies object into this one.
+
+        Args:
+            other: The NodeDependencies object to aggregate from
+        """
+        # Aggregate all dependency types - no None checks needed since we use default_factory=set
+        self.referenced_workflows.update(other.referenced_workflows)
+        self.static_files.update(other.static_files)
+        self.imports.update(other.imports)
+        self.libraries.update(other.libraries)
+
 
 class NodeResolutionState(StrEnum):
     """Possible states for a node during resolution."""
@@ -59,6 +108,23 @@ class NodeResolutionState(StrEnum):
     RESOLVED = auto()
 
 
+def get_library_names_with_publish_handlers() -> list[str]:
+    """Get names of all registered libraries that have PublishWorkflowRequest handlers."""
+    from griptape_nodes.retained_mode.events.workflow_events import PublishWorkflowRequest
+    from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
+    library_manager = GriptapeNodes.LibraryManager()
+    event_handlers = library_manager.get_registered_event_handlers(PublishWorkflowRequest)
+
+    # Always include "local" as the first option
+    library_names = [LOCAL_EXECUTION]
+
+    # Add all registered library names that can handle PublishWorkflowRequest
+    library_names.extend(sorted(event_handlers.keys()))
+
+    return library_names
+
+
 class BaseNode(ABC):
     # Owned by a flow
     name: str
@@ -104,6 +170,16 @@ class BaseNode(ABC):
         self.process_generator = None
         self._tracked_parameters = []
         self.set_entry_control_parameter(None)
+        self.execution_environment = Parameter(
+            name="execution_environment",
+            tooltip="Environment that the node should execute in",
+            type=ParameterTypeBuiltin.STR,
+            allowed_modes={ParameterMode.PROPERTY},
+            default_value=LOCAL_EXECUTION,
+            traits={Options(choices=get_library_names_with_publish_handlers())},
+            ui_options={"hide": True},
+        )
+        self.add_parameter(self.execution_environment)
 
     # This is gross and we need to have a universal pass on resolution state changes and emission of events. That's what this ticket does!
     # https://github.com/griptape-ai/griptape-nodes/issues/994
@@ -819,6 +895,35 @@ class BaseNode(ABC):
         # Then clear the reference to the first spotlight parameter
         self.current_spotlight_parameter = None
 
+    def get_node_dependencies(self) -> NodeDependencies | None:
+        """Return the dependencies that this node has on external resources.
+
+        This method should be overridden by nodes that have dependencies on:
+        - Referenced workflows: Other workflows that this node calls or references
+        - Static files: Files that this node reads from or requires for operation
+        - Python imports: Modules or classes that this node imports beyond standard dependencies
+
+        This information can be used by the system for workflow packaging, dependency
+        resolution, deployment planning, and ensuring all required resources are available.
+
+        Returns:
+            NodeDependencies object containing the node's dependencies, or None if the node
+            has no external dependencies beyond the standard framework dependencies.
+
+        Example:
+            def get_node_dependencies(self) -> NodeDependencies | None:
+                return NodeDependencies(
+                    referenced_workflows={"image_processing_workflow", "validation_workflow"},
+                    static_files={"config.json", "model_weights.pkl"},
+                    imports={
+                        ImportDependency("numpy"),
+                        ImportDependency("sklearn.linear_model", "LinearRegression"),
+                        ImportDependency("custom_module", "SpecialProcessor")
+                    }
+                )
+        """
+        return None
+
     def append_value_to_parameter(self, parameter_name: str, value: Any) -> None:
         from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
@@ -1390,6 +1495,16 @@ class EndNode(BaseNode):
 
         self.status_component.set_execution_result(was_successful=was_successful, result_details=details)
 
+        # Update all values to use the output value
+        for param in self.parameters:
+            if param.type != ParameterTypeBuiltin.CONTROL_TYPE:
+                value = self.get_parameter_value(param.name)
+                self.parameter_output_values[param.name] = value
+        next_control_output = self.get_next_control_output()
+        # Update which control parameter to flag as the output value.
+        if next_control_output is not None:
+            self.parameter_output_values[next_control_output.name] = 1
+
 
 class StartLoopNode(BaseNode):
     end_node: EndLoopNode | None = None

griptape_nodes/retained_mode/events/agent_events.py

@@ -29,12 +29,14 @@ class RunAgentRequest(RequestPayload):
     Args:
         input: Text input to send to the agent
         url_artifacts: List of URL artifacts to include with the request
+        additional_mcp_servers: List of additional MCP server names to include
 
     Results: RunAgentResultStarted -> RunAgentResultSuccess (with output) | RunAgentResultFailure (execution error)
     """
 
     input: str
     url_artifacts: list[RunAgentRequestArtifact]
+    additional_mcp_servers: list[str] = field(default_factory=list)
 
 
 @dataclass

griptape_nodes/retained_mode/events/base_events.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 import logging
 from abc import ABC, abstractmethod
-from dataclasses import asdict, dataclass, field, is_dataclass
+from dataclasses import asdict, dataclass, field, fields, is_dataclass
 from typing import TYPE_CHECKING, Any, ClassVar, TypeVar
 
 from griptape.artifacts import BaseArtifact
@@ -389,6 +389,21 @@ class EventResult[P: RequestPayload, R: ResultPayload](BaseEvent, ABC):
             bool: True if success, False if failure
         """
 
+    @classmethod
+    def _create_payload_instance(cls, payload_type: type, payload_data: dict[str, Any]) -> Any:
+        """Create a payload instance from data, handling dataclass init=False fields."""
+        if is_dataclass(payload_type):
+            # Filter out fields that have init=False to avoid TypeError
+            init_fields = {f.name for f in fields(payload_type) if f.init}
+            filtered_data = {k: v for k, v in payload_data.items() if k in init_fields}
+            return payload_type(**filtered_data)
+        if issubclass(payload_type, BaseModel):
+            return payload_type.model_validate(payload_data)
+        instance = payload_type()
+        for key, value in payload_data.items():
+            setattr(instance, key, value)
+        return instance
+
     @classmethod
     def from_dict(  # pyright: ignore[reportIncompatibleMethodOverride]
         cls, data: builtins.dict[str, Any], req_payload_type: type[P], res_payload_type: type[R]
@@ -403,28 +418,14 @@ class EventResult[P: RequestPayload, R: ResultPayload](BaseEvent, ABC):
 
         # Process request payload
         if req_payload_type:
-            if is_dataclass(req_payload_type):
-                request_payload = req_payload_type(**request_data)
-            elif issubclass(req_payload_type, BaseModel):
-                request_payload = req_payload_type.model_validate(request_data)
-            else:
-                request_payload = req_payload_type()
-                for key, value in request_data.items():
-                    setattr(request_payload, key, value)
+            request_payload = cls._create_payload_instance(req_payload_type, request_data)
         else:
             msg = f"Cannot create {cls.__name__} without a request payload type"
             raise ValueError(msg)
 
         # Process result payload
         if res_payload_type:
-            if is_dataclass(res_payload_type):
-                result_payload = res_payload_type(**result_data)
-            elif issubclass(res_payload_type, BaseModel):
-                result_payload = res_payload_type.model_validate(result_data)
-            else:
-                result_payload = res_payload_type()
-                for key, value in result_data.items():
-                    setattr(result_payload, key, value)
+            result_payload = cls._create_payload_instance(res_payload_type, result_data)
         else:
             msg = f"Cannot create {cls.__name__} without a result payload type"
             raise ValueError(msg)

griptape_nodes/retained_mode/events/execution_events.py

@@ -4,6 +4,7 @@ from typing import Any
 from griptape_nodes.retained_mode.events.base_events import (
     ExecutionPayload,
     RequestPayload,
+    ResultDetails,
     ResultPayloadFailure,
     ResultPayloadSuccess,
     WorkflowAlteredMixin,
@@ -307,7 +308,8 @@ class ControlFlowResolvedEvent(ExecutionPayload):
 @dataclass
 @PayloadRegistry.register
 class ControlFlowCancelledEvent(ExecutionPayload):
-    pass
+    result_details: ResultDetails | str | None = None
+    exception: Exception | None = None
 
 
 @dataclass

griptape_nodes/retained_mode/events/flow_events.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import Any
 
-from griptape_nodes.node_library.library_registry import LibraryNameAndVersion
+from griptape_nodes.exe_types.node_types import NodeDependencies
 from griptape_nodes.node_library.workflow_registry import WorkflowShape
 from griptape_nodes.retained_mode.events.base_events import (
     RequestPayload,
@@ -186,8 +186,6 @@ class SerializedFlowCommands:
     Useful for save/load, copy/paste, etc.
 
     Attributes:
-        node_libraries_used (set[LibraryNameAndVersion]): Set of libraries and versions used by the nodes,
-            including those in child flows.
         flow_initialization_command (CreateFlowRequest | ImportWorkflowAsReferencedSubFlowRequest | None): Command to initialize the flow that contains all of this.
             Can be CreateFlowRequest for standalone flows, ImportWorkflowAsReferencedSubFlowRequest for referenced workflows,
             or None to deserialize into whatever Flow is in the Current Context.
@@ -200,8 +198,9 @@ class SerializedFlowCommands:
         set_parameter_value_commands (dict[SerializedNodeCommands.NodeUUID, list[SerializedNodeCommands.IndirectSetParameterValueCommand]]): List of commands
             to set parameter values, keyed by node UUID, during deserialization.
         sub_flows_commands (list["SerializedFlowCommands"]): List of sub-flow commands. Cascades into sub-flows within this serialization.
-        referenced_workflows (set[str]): Set of workflow file paths that are referenced by this flow and its sub-flows.
-            Used for validation before deserialization to ensure all referenced workflows are available.
+        node_dependencies (NodeDependencies): Aggregated dependencies from all nodes in this flow and its sub-flows.
+            Includes referenced workflows, static files, Python imports, and libraries. Used for workflow packaging,
+            dependency resolution, and deployment planning.
     """
 
     @dataclass
@@ -222,7 +221,6 @@ class SerializedFlowCommands:
         target_node_uuid: SerializedNodeCommands.NodeUUID
         target_parameter_name: str
 
-    node_libraries_used: set[LibraryNameAndVersion]
     flow_initialization_command: CreateFlowRequest | ImportWorkflowAsReferencedSubFlowRequest | None
     serialized_node_commands: list[SerializedNodeCommands]
     serialized_connections: list[IndirectConnectionSerialization]
@@ -232,7 +230,7 @@ class SerializedFlowCommands:
     ]
     set_lock_commands_per_node: dict[SerializedNodeCommands.NodeUUID, SetLockNodeStateRequest]
     sub_flows_commands: list["SerializedFlowCommands"]
-    referenced_workflows: set[str]
+    node_dependencies: NodeDependencies
 
 
 @dataclass