griptape-nodes 0.63.10__py3-none-any.whl → 0.64.0__py3-none-any.whl

griptape_nodes/machines/parallel_resolution.py

@@ -11,7 +11,6 @@ from griptape_nodes.exe_types.node_types import (
     CONTROL_INPUT_PARAMETER,
     LOCAL_EXECUTION,
     BaseNode,
-    NodeGroupProxyNode,
     NodeResolutionState,
 )
 from griptape_nodes.exe_types.type_validator import TypeValidator
@@ -129,12 +128,6 @@ class ExecuteDagState(State):
                 network_name,
             )
             return
-
-        # Check if this is a NodeGroupProxyNode - if so, handle grouped nodes
-
-        if isinstance(current_node, NodeGroupProxyNode):
-            await ExecuteDagState._handle_group_proxy_completion(context, current_node, network_name)
-            return
         # Publish all parameter updates.
         current_node.state = NodeResolutionState.RESOLVED
         # Track this as the last resolved node
@@ -192,171 +185,6 @@ class ExecuteDagState(State):
         # Now the final thing to do, is to take their directed graph and update it.
         ExecuteDagState.get_next_control_graph(context, current_node, network_name)
 
-    # Method is mirrored in Control_flow.py. If you update one, update the other.
-    @staticmethod
-    async def _handle_group_proxy_completion(
-        context: ParallelResolutionContext, proxy_node: BaseNode, network_name: str
-    ) -> None:
-        """Handle completion of a NodeGroupProxyNode by marking all grouped nodes as resolved.
-
-        When a NodeGroupProxyNode completes, all nodes in the group have been executed
-        in parallel by the NodeExecutor. This method marks each grouped node as RESOLVED
-        and emits NodeResolvedEvent for each one.
-
-        Args:
-            proxy_node: The NodeGroupProxyNode that completed execution
-            context: The ParallelResolutionContext
-            network_name: The name of the network
-        """
-        from griptape_nodes.exe_types.node_types import NodeGroupProxyNode
-
-        if not isinstance(proxy_node, NodeGroupProxyNode):
-            return
-
-        node_group = proxy_node.node_group_data
-
-        # Mark all grouped nodes as resolved and emit events
-        proxy_node.state = NodeResolutionState.RESOLVED
-        for grouped_node in node_group.nodes.values():
-            # Mark node as resolved
-            grouped_node.state = NodeResolutionState.RESOLVED
-
-            # Emit parameter update events for each output parameter
-            for parameter_name, value in grouped_node.parameter_output_values.items():
-                parameter = grouped_node.get_parameter_by_name(parameter_name)
-                if parameter is None:
-                    logger.warning(
-                        "Node '%s' in group '%s' has output parameter '%s' but parameter not found",
-                        grouped_node.name,
-                        node_group.group_id,
-                        parameter_name,
-                    )
-                    continue
-
-                data_type = parameter.type
-                if data_type is None:
-                    data_type = ParameterTypeBuiltin.NONE.value
-
-                await GriptapeNodes.EventManager().aput_event(
-                    ExecutionGriptapeNodeEvent(
-                        wrapped_event=ExecutionEvent(
-                            payload=ParameterValueUpdateEvent(
-                                node_name=grouped_node.name,
-                                parameter_name=parameter_name,
-                                data_type=data_type,
-                                value=TypeValidator.safe_serialize(value),
-                            )
-                        ),
-                    )
-                )
-
-            # Emit NodeResolvedEvent for the grouped node
-            library = LibraryRegistry.get_libraries_with_node_type(grouped_node.__class__.__name__)
-            library_name = library[0] if len(library) == 1 else None
-
-            await GriptapeNodes.EventManager().aput_event(
-                ExecutionGriptapeNodeEvent(
-                    wrapped_event=ExecutionEvent(
-                        payload=NodeResolvedEvent(
-                            node_name=grouped_node.name,
-                            parameter_output_values=TypeValidator.safe_serialize(grouped_node.parameter_output_values),
-                            node_type=grouped_node.__class__.__name__,
-                            specific_library_name=library_name,
-                        )
-                    )
-                )
-            )
-
-        # Cleanup: restore connections and deregister proxy
-        ExecuteDagState.get_next_control_graph(context, proxy_node, network_name)
-        ExecuteDagState._cleanup_proxy_node(proxy_node)
-
-    @staticmethod
-    def _cleanup_proxy_node(proxy_node: BaseNode) -> None:
-        """Clean up a NodeGroupProxyNode after execution completes.
-
-        Restores original connections from proxy back to grouped nodes and
-        deregisters the proxy node from ObjectManager.
-
-        Args:
-            proxy_node: The NodeGroupProxyNode to clean up
-        """
-        from griptape_nodes.exe_types.node_types import NodeGroupProxyNode
-
-        if not isinstance(proxy_node, NodeGroupProxyNode):
-            return
-
-        node_group = proxy_node.node_group_data
-        connections = GriptapeNodes.FlowManager().get_connections()
-
-        # Restore external incoming connections (proxy -> original target node)
-        for conn in node_group.external_incoming_connections:
-            conn_id = id(conn)
-
-            # Get original target node
-            original_target = node_group.original_incoming_targets.get(conn_id)
-            if original_target is None:
-                continue
-
-            # Create proxy parameter name to find it in the index
-            sanitized_node_name = original_target.name.replace(" ", "_")
-            proxy_param_name = f"{sanitized_node_name}__{conn.target_parameter.name}"
-
-            # Remove proxy from incoming index (using proxy parameter name)
-            if (
-                proxy_node.name in connections.incoming_index
-                and proxy_param_name in connections.incoming_index[proxy_node.name]
-            ):
-                connections.incoming_index[proxy_node.name][proxy_param_name].remove(conn_id)
-
-            # Restore connection to original target node
-            conn.target_node = original_target
-
-            # Add back to original target node's incoming index (using original parameter name)
-            connections.incoming_index.setdefault(conn.target_node.name, {}).setdefault(
-                conn.target_parameter.name, []
-            ).append(conn_id)
-
-        # Restore external outgoing connections (original source node -> proxy)
-        for conn in node_group.external_outgoing_connections:
-            conn_id = id(conn)
-
-            # Get original source node
-            original_source = node_group.original_outgoing_sources.get(conn_id)
-            if original_source is None:
-                continue
-
-            # Create proxy parameter name to find it in the index
-            sanitized_node_name = original_source.name.replace(" ", "_")
-            proxy_param_name = f"{sanitized_node_name}__{conn.source_parameter.name}"
-
-            # Remove proxy from outgoing index (using proxy parameter name)
-            if (
-                proxy_node.name in connections.outgoing_index
-                and proxy_param_name in connections.outgoing_index[proxy_node.name]
-            ):
-                connections.outgoing_index[proxy_node.name][proxy_param_name].remove(conn_id)
-
-            # Restore connection to original source node
-            conn.source_node = original_source
-
-            # Add back to original source node's outgoing index (using original parameter name)
-            connections.outgoing_index.setdefault(conn.source_node.name, {}).setdefault(
-                conn.source_parameter.name, []
-            ).append(conn_id)
-
-        # Deregister proxy node from ObjectManager
-        obj_manager = GriptapeNodes.ObjectManager()
-        if obj_manager.has_object_with_name(proxy_node.name):
-            del obj_manager._name_to_objects[proxy_node.name]
-
-        logger.debug(
-            "Cleaned up proxy node '%s' for group '%s' - restored %d connections",
-            proxy_node.name,
-            node_group.group_id,
-            len(node_group.external_incoming_connections) + len(node_group.external_outgoing_connections),
-        )
-
     @staticmethod
     def get_next_control_output_for_non_local_execution(node: BaseNode) -> Parameter | None:
         for param_name, value in node.parameter_output_values.items():
@@ -381,11 +209,12 @@ class ExecuteDagState(State):
         # Early returns for various conditions
         if ExecuteDagState._should_skip_control_flow(context, node, network_name, flow_manager):
             return
-        if node.get_parameter_value(node.execution_environment.name) != LOCAL_EXECUTION:
-            next_output = ExecuteDagState.get_next_control_output_for_non_local_execution(node)
-        else:
-            next_output = node.get_next_control_output()
-        if node.get_parameter_value(node.execution_environment.name) != LOCAL_EXECUTION:
+        from griptape_nodes.exe_types.node_types import NodeGroupNode
+
+        if (
+            isinstance(node, NodeGroupNode)
+            and node.get_parameter_value(node.execution_environment.name) != LOCAL_EXECUTION
+        ):
             next_output = ExecuteDagState.get_next_control_output_for_non_local_execution(node)
         else:
             next_output = node.get_next_control_output()
@@ -425,14 +254,6 @@ class ExecuteDagState(State):
         """Process the next control node in the flow."""
         node_connection = flow_manager.get_connections().get_connected_node(node, next_output)
         if node_connection is not None:
-            next_node, next_parameter = node_connection
-            # Set entry control parameter
-            logger.debug(
-                "Parallel Resolution: Setting entry control parameter for node '%s' to '%s'",
-                next_node.name,
-                next_parameter.name if next_parameter else None,
-            )
-            next_node.set_entry_control_parameter(next_parameter)
             next_node, next_parameter = node_connection
             # Set entry control parameter
             logger.debug(
@@ -519,7 +340,6 @@ class ExecuteDagState(State):
         for parameter in current_node.parameters:
             # Get the connected upstream node for this parameter
             upstream_connection = connections.get_connected_node(current_node, parameter, direction=Direction.UPSTREAM)
-            upstream_connection = connections.get_connected_node(current_node, parameter, direction=Direction.UPSTREAM)
             if upstream_connection:
                 upstream_node, upstream_parameter = upstream_connection
 
@@ -544,20 +364,6 @@ class ExecuteDagState(State):
                     msg = f"Failed to set value for parameter '{parameter.name}' on node '{current_node.name}': {result.result_details}"
                     logger.error(msg)
                     raise RuntimeError(msg)
-                result = await GriptapeNodes.get_instance().ahandle_request(
-                    SetParameterValueRequest(
-                        parameter_name=parameter.name,
-                        node_name=current_node.name,
-                        value=output_value,
-                        data_type=upstream_parameter.output_type,
-                        incoming_connection_source_node_name=upstream_node.name,
-                        incoming_connection_source_parameter_name=upstream_parameter.name,
-                    )
-                )
-                if isinstance(result, SetParameterValueResultFailure):
-                    msg = f"Failed to set value for parameter '{parameter.name}' on node '{current_node.name}': {result.result_details}"
-                    logger.error(msg)
-                    raise RuntimeError(msg)
 
     @staticmethod
     def build_node_states(context: ParallelResolutionContext) -> tuple[set[str], set[str], set[str]]:
@@ -582,6 +388,7 @@ class ExecuteDagState(State):
                 canceled_nodes.add(node)
             elif node_state == NodeState.QUEUED:
                 queued_nodes.add(node)
+
         return canceled_nodes, queued_nodes, leaf_nodes
 
     @staticmethod
@@ -636,7 +443,7 @@ class ExecuteDagState(State):
         return None
 
     @staticmethod
-    async def on_update(context: ParallelResolutionContext) -> type[State] | None:  # noqa: C901, PLR0911, PLR0915
+    async def on_update(context: ParallelResolutionContext) -> type[State] | None:  # noqa: C901, PLR0911
         # Check if execution is paused
         if context.paused:
             return None
@@ -728,26 +535,12 @@ class ExecuteDagState(State):
                         exc,
                     )
 
-                    dag_node = context.task_to_node.get(task)
-                    node_name = dag_node.node_reference.name if dag_node else "Unknown"
-                    node_type = dag_node.node_reference.__class__.__name__ if dag_node else "Unknown"
-
-                    logger.exception(
-                        "Task execution failed for node '%s' (type: %s) in flow '%s'. Exception: %s",
-                        node_name,
-                        node_type,
-                        context.flow_name,
-                        exc,
-                    )
-
                     context.task_to_node.pop(task)
                     context.error_message = f"Task execution failed for node '{node_name}': {exc}"
                     context.workflow_state = WorkflowState.ERRORED
                     return ErrorState
-                    context.error_message = f"Task execution failed for node '{node_name}': {exc}"
-                    context.workflow_state = WorkflowState.ERRORED
-                    return ErrorState
                 context.task_to_node.pop(task)
+
         # Once a task has finished, loop back to the top.
         await ExecuteDagState.pop_done_states(context)
         # Remove all nodes that are done
@@ -762,18 +555,7 @@ class ErrorState(State):
         if context.error_message:
             logger.error("DAG execution error: %s", context.error_message)
 
-        # Clean up any proxy nodes that failed before completion
-        from griptape_nodes.exe_types.node_types import NodeGroupProxyNode
-
         for node in context.node_to_reference.values():
-            # Clean up proxy nodes that were processing or queued
-            if isinstance(node.node_reference, NodeGroupProxyNode) and node.node_state in (
-                NodeState.PROCESSING,
-                NodeState.QUEUED,
-            ):
-                logger.info("Cleaning up proxy node '%s' that failed during execution", node.node_reference.name)
-                ExecuteDagState._cleanup_proxy_node(node.node_reference)
-
             # Cancel all nodes that haven't yet begun processing.
             if node.node_state == NodeState.QUEUED:
                 node.node_state = NodeState.CANCELED
@@ -796,15 +578,6 @@ class ErrorState(State):
                 node.node_state = NodeState.CANCELED
             task_to_node.pop(task)
 
-        # Handle async tasks
-        task_to_node = context.task_to_node
-        for task, node in task_to_node.copy().items():
-            if task.done():
-                node.node_state = NodeState.DONE
-            elif task.cancelled():
-                node.node_state = NodeState.CANCELED
-            task_to_node.pop(task)
-
         if len(task_to_node) == 0:
             # Finish up. We failed.
             context.workflow_state = WorkflowState.ERRORED

griptape_nodes/machines/sequential_resolution.py

@@ -3,10 +3,11 @@ from __future__ import annotations
 import asyncio
 import logging
 from dataclasses import dataclass
+from typing import Any
 
 from griptape_nodes.exe_types.connections import Direction
 from griptape_nodes.exe_types.core_types import ParameterTypeBuiltin
-from griptape_nodes.exe_types.node_types import BaseNode, NodeResolutionState
+from griptape_nodes.exe_types.node_types import LOCAL_EXECUTION, BaseNode, NodeGroupNode, NodeResolutionState
 from griptape_nodes.exe_types.type_validator import TypeValidator
 from griptape_nodes.machines.fsm import FSM, State
 from griptape_nodes.node_library.library_registry import LibraryRegistry
@@ -77,6 +78,43 @@ class InitializeSpotlightState(State):
         if not len(context.focus_stack):
             return CompleteState
         current_node = context.current_node
+
+        # If this node has a non-LOCAL parent group, redirect to parent instead
+        # Handle nested groups recursively - keep redirecting until we find the top-level parent
+        from griptape_nodes.exe_types.node_types import LOCAL_EXECUTION, NodeGroupNode
+
+        while current_node.parent_group is not None and isinstance(current_node.parent_group, NodeGroupNode):
+            execution_env = current_node.parent_group.get_parameter_value(
+                current_node.parent_group.execution_environment.name
+            )
+            if execution_env != LOCAL_EXECUTION:
+                # Replace current node with parent group
+                parent_group = current_node.parent_group
+                logger.info(
+                    "Sequential Resolution: Redirecting from child node '%s' to parent node group '%s' at InitializeSpotlight",
+                    current_node.name,
+                    parent_group.name,
+                )
+                # Update the focus stack to use parent instead
+                context.focus_stack[-1] = Focus(node=parent_group)
+                current_node = parent_group
+                # Continue loop to check if this parent also has a parent
+            else:
+                # Parent is LOCAL_EXECUTION, stop redirecting
+                break
+
+        # For NodeGroups, check external connections for unresolved dependencies
+        if isinstance(current_node, NodeGroupNode):
+            unresolved_dependency = EvaluateParameterState._check_node_group_external_dependencies(current_node)
+            if unresolved_dependency:
+                logger.info(
+                    "Sequential Resolution: NodeGroup '%s' has unresolved external dependency on '%s', queuing dependency first",
+                    current_node.name,
+                    unresolved_dependency.name,
+                )
+                context.focus_stack.append(Focus(node=unresolved_dependency))
+                return InitializeSpotlightState
+
         if current_node.state == NodeResolutionState.UNRESOLVED:
             # Mark all future nodes unresolved.
             # TODO: https://github.com/griptape-ai/griptape-nodes/issues/862
@@ -120,27 +158,111 @@ class EvaluateParameterState(State):
             return EvaluateParameterState
         return None
 
+    @staticmethod
+    def _get_next_node(current_node: BaseNode, current_parameter: Any, connections: Any) -> BaseNode | None:
+        """Get the next node connected to the current parameter."""
+        next_node = connections.get_connected_node(current_node, current_parameter)
+        if next_node:
+            next_node, _ = next_node
+        return next_node
+
+    @staticmethod
+    def _check_for_cycle(next_node: BaseNode, current_node: BaseNode, focus_stack_names: set[str]) -> None:
+        """Check if queuing next_node would create a cycle."""
+        if next_node.name in focus_stack_names:
+            msg = f"Cycle detected between node '{current_node.name}' and '{next_node.name}'."
+            raise RuntimeError(msg)
+
+    @staticmethod
+    def _handle_parent_already_resolved(current_node: BaseNode) -> type[State]:
+        """Handle case where parent node group is already resolved."""
+        if current_node.advance_parameter():
+            return InitializeSpotlightState
+        return ExecuteNodeState
+
+    @staticmethod
+    def _check_node_group_external_dependencies(node_group: BaseNode) -> BaseNode | None:
+        """Check if NodeGroup has unresolved external incoming connections.
+
+        Returns the first unresolved source node (or its parent if applicable) if found, None otherwise.
+        """
+        if not isinstance(node_group, NodeGroupNode):
+            return None
+
+        for conn in node_group.stored_connections.external_connections.incoming_connections:
+            source_node = conn.source_node
+            if source_node.state == NodeResolutionState.UNRESOLVED:
+                # Check if source has a parent group to use instead
+                if source_node.parent_group is not None and isinstance(source_node.parent_group, NodeGroupNode):
+                    execution_env = source_node.parent_group.get_parameter_value(
+                        source_node.parent_group.execution_environment.name
+                    )
+                    if execution_env != LOCAL_EXECUTION:
+                        return source_node.parent_group
+                return source_node
+        return None
+
+    @staticmethod
+    def _determine_node_to_queue(
+        next_node: BaseNode, current_node: BaseNode, focus_stack_names: set[str]
+    ) -> BaseNode | None:
+        """Determine which node to queue - the next node or its parent group.
+
+        Returns None if the parent node group is already resolved.
+        """
+        if next_node.parent_group is None or not isinstance(next_node.parent_group, NodeGroupNode):
+            return next_node
+
+        parent_group = next_node.parent_group
+        execution_env = parent_group.get_parameter_value(parent_group.execution_environment.name)
+        if execution_env == LOCAL_EXECUTION:
+            return next_node
+
+        if parent_group.state == NodeResolutionState.RESOLVED:
+            logger.info(
+                "Sequential Resolution: Parent node group '%s' is already resolved, skipping child node '%s' (execution environment: %s)",
+                parent_group.name,
+                next_node.name,
+                execution_env,
+            )
+            return None
+
+        if parent_group.name in focus_stack_names:
+            msg = f"Cycle detected: parent node group '{parent_group.name}' is already in focus stack while processing dependency for '{current_node.name}'."
+            raise RuntimeError(msg)
+
+        logger.info(
+            "Sequential Resolution: Queuing parent node group '%s' instead of child node '%s' (execution environment: %s) - child is a dependency of '%s'",
+            parent_group.name,
+            next_node.name,
+            execution_env,
+            current_node.name,
+        )
+        return parent_group
+
     @staticmethod
     async def on_update(context: ResolutionContext) -> type[State] | None:
+        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
+
         current_node = context.current_node
         current_parameter = current_node.get_current_parameter()
-        from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
-        connections = GriptapeNodes.FlowManager().get_connections()
         if current_parameter is None:
             msg = "No current parameter set."
             raise ValueError(msg)
-        # Get the next node
-        next_node = connections.get_connected_node(current_node, current_parameter)
-        if next_node:
-            next_node, _ = next_node
+
+        connections = GriptapeNodes.FlowManager().get_connections()
+        next_node = EvaluateParameterState._get_next_node(current_node, current_parameter, connections)
+
         if next_node and next_node.state == NodeResolutionState.UNRESOLVED:
             focus_stack_names = {focus.node.name for focus in context.focus_stack}
-            if next_node.name in focus_stack_names:
-                msg = f"Cycle detected between node '{current_node.name}' and '{next_node.name}'."
-                raise RuntimeError(msg)
+            EvaluateParameterState._check_for_cycle(next_node, current_node, focus_stack_names)
+
+            node_to_queue = EvaluateParameterState._determine_node_to_queue(next_node, current_node, focus_stack_names)
+            if node_to_queue is None:
+                return EvaluateParameterState._handle_parent_already_resolved(current_node)
 
-            context.focus_stack.append(Focus(node=next_node))
+            context.focus_stack.append(Focus(node=node_to_queue))
             return InitializeSpotlightState
 
         if current_node.advance_parameter():

griptape_nodes/retained_mode/events/agent_events.py

@@ -120,11 +120,13 @@ class ConfigureAgentRequest(RequestPayload):
 
     Args:
         prompt_driver: Dictionary of prompt driver configuration options
+        image_generation_driver: Dictionary of image generation driver configuration options
 
     Results: ConfigureAgentResultSuccess | ConfigureAgentResultFailure (configuration error)
     """
 
     prompt_driver: dict = field(default_factory=dict)
+    image_generation_driver: dict = field(default_factory=dict)
 
 
 @dataclass

griptape_nodes/retained_mode/events/flow_events.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, NamedTuple
 
 if TYPE_CHECKING:
-    from griptape_nodes.exe_types.node_types import NodeDependencies, NodeGroupProxyNode
+    from griptape_nodes.exe_types.node_types import NodeDependencies
     from griptape_nodes.node_library.workflow_registry import LibraryNameAndNodeType, WorkflowShape
     from griptape_nodes.retained_mode.events.node_events import SerializedNodeCommands, SetLockNodeStateRequest
     from griptape_nodes.retained_mode.events.workflow_events import ImportWorkflowAsReferencedSubFlowRequest
@@ -428,7 +428,8 @@ class PackageNodesAsSerializedFlowRequest(RequestPayload):
         node_names: List of node names to package as a flow (empty list will create StartFlow→EndFlow only with warning)
         start_node_type: Node type name for the artificial start node (None or omitted defaults to "StartFlow")
         end_node_type: Node type name for the artificial end node (None or omitted defaults to "EndFlow")
-        start_end_specific_library_name: Library name containing the start/end nodes (defaults to "Griptape Nodes Library")
+        start_node_library_name: Library name containing the start node (defaults to "Griptape Nodes Library")
+        end_node_library_name: Library name containing the end node (defaults to "Griptape Nodes Library")
         entry_control_node_name: Name of the node that should receive the control flow entry (required if entry_control_parameter_name specified)
         entry_control_parameter_name: Name of the control parameter on the entry node (None for auto-detection of first available control parameter)
         output_parameter_prefix: Prefix for parameter names on the generated end node to avoid collisions (defaults to "packaged_node_")
@@ -440,13 +441,11 @@ class PackageNodesAsSerializedFlowRequest(RequestPayload):
     node_names: list[str] = field(default_factory=list)
     start_node_type: str | None = None
     end_node_type: str | None = None
-    start_end_specific_library_name: str = "Griptape Nodes Library"
+    start_node_library_name: str = "Griptape Nodes Library"
+    end_node_library_name: str = "Griptape Nodes Library"
     entry_control_node_name: str | None = None
     entry_control_parameter_name: str | None = None
     output_parameter_prefix: str = "packaged_node_"
-    proxy_node: NodeGroupProxyNode | None = (
-        None  # NodeGroupProxyNode if packaging nodes from a proxy, used to access original connections
-    )
 
 
 @dataclass