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

griptape_nodes/machines/parallel_resolution.py

@@ -7,7 +7,13 @@ from typing import TYPE_CHECKING
 
 from griptape_nodes.exe_types.connections import Direction
 from griptape_nodes.exe_types.core_types import Parameter, ParameterTypeBuiltin
-from griptape_nodes.exe_types.node_types import CONTROL_INPUT_PARAMETER, LOCAL_EXECUTION, BaseNode, NodeResolutionState
+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
 from griptape_nodes.machines.dag_builder import NodeState
 from griptape_nodes.machines.fsm import FSM, State
@@ -56,6 +62,7 @@ class ParallelResolutionContext:
     task_to_node: dict[asyncio.Task, DagNode]
     dag_builder: DagBuilder | None
     last_resolved_node: BaseNode | None  # Track the last node that was resolved
+    last_resolved_node: BaseNode | None  # Track the last node that was resolved
 
     def __init__(
         self, flow_name: str, max_nodes_in_parallel: int | None = None, dag_builder: DagBuilder | None = None
@@ -66,6 +73,7 @@ class ParallelResolutionContext:
         self.workflow_state = WorkflowState.NO_ERROR
         self.dag_builder = dag_builder
         self.last_resolved_node = None
+        self.last_resolved_node = None
 
         # Initialize execution fields
         max_nodes_in_parallel = max_nodes_in_parallel if max_nodes_in_parallel is not None else 5
@@ -101,6 +109,7 @@ class ParallelResolutionContext:
             self.error_message = None
             self.task_to_node.clear()
             self.last_resolved_node = None
+            self.last_resolved_node = None
 
         # Clear DAG builder state to allow re-adding nodes on subsequent runs
         if self.dag_builder:
@@ -121,10 +130,17 @@ class ExecuteDagState(State):
             )
             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
         context.last_resolved_node = current_node
+        # Track this as the last resolved node
+        context.last_resolved_node = current_node
         # Serialization can be slow so only do it if the user wants debug details.
         if logger.level <= logging.DEBUG:
             logger.debug(
@@ -177,6 +193,170 @@ class ExecuteDagState(State):
         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():
@@ -205,6 +385,10 @@ class ExecuteDagState(State):
             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:
+            next_output = ExecuteDagState.get_next_control_output_for_non_local_execution(node)
+        else:
+            next_output = node.get_next_control_output()
         if next_output is not None:
             ExecuteDagState._process_next_control_node(context, node, next_output, network_name, flow_manager)
 
@@ -241,6 +425,14 @@ 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(
@@ -327,6 +519,7 @@ 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
 
@@ -351,6 +544,20 @@ 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]]:
@@ -411,8 +618,6 @@ class ExecuteDagState(State):
     @staticmethod
     async def execute_node(current_node: DagNode, semaphore: asyncio.Semaphore) -> None:
         async with semaphore:
-            from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
-
             executor = GriptapeNodes.FlowManager().node_executor
             await executor.execute(current_node.node_reference)
 
@@ -431,7 +636,7 @@ class ExecuteDagState(State):
         return None
 
     @staticmethod
-    async def on_update(context: ParallelResolutionContext) -> type[State] | None:  # noqa: C901, PLR0911
+    async def on_update(context: ParallelResolutionContext) -> type[State] | None:  # noqa: C901, PLR0911, PLR0915
         # Check if execution is paused
         if context.paused:
             return None
@@ -523,10 +728,25 @@ 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)
@@ -541,10 +761,23 @@ class ErrorState(State):
     async def on_enter(context: ParallelResolutionContext) -> type[State] | None:
         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
+
         # Shut down and cancel all threads/tasks that haven't yet ran. Currently running ones will not be affected.
         # Cancel async tasks
         for task in list(context.task_to_node.keys()):

griptape_nodes/node_library/workflow_registry.py

@@ -45,7 +45,7 @@ class WorkflowShape(BaseModel):
 
 
 class WorkflowMetadata(BaseModel):
-    LATEST_SCHEMA_VERSION: ClassVar[str] = "0.9.0"
+    LATEST_SCHEMA_VERSION: ClassVar[str] = "0.10.0"
 
     name: str
     schema_version: str

griptape_nodes/retained_mode/events/execution_events.py

@@ -227,12 +227,13 @@ class GetFlowStateResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
     """Flow execution state retrieved successfully.
 
     Args:
-        control_node: Name of the current control node (if any)
-        resolving_node: Name of the node currently being resolved (if any)
+        control_nodes: Name of the current control node (if any)
+        resolving_nodes: Name of the node currently being resolved (if any)
     """
 
-    control_nodes: list[str] | None
-    resolving_node: list[str] | None
+    control_nodes: list[str]
+    resolving_nodes: list[str]
+    involved_nodes: list[str]
 
 
 @dataclass

griptape_nodes/retained_mode/events/flow_events.py

@@ -1,8 +1,14 @@
+from __future__ import annotations
+
 from dataclasses import dataclass, field
-from typing import Any, NamedTuple
+from typing import TYPE_CHECKING, Any, NamedTuple
+
+if TYPE_CHECKING:
+    from griptape_nodes.exe_types.node_types import NodeDependencies, NodeGroupProxyNode
+    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
 
-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.base_events import (
     RequestPayload,
     ResultPayloadFailure,
@@ -10,9 +16,7 @@ from griptape_nodes.retained_mode.events.base_events import (
     WorkflowAlteredMixin,
     WorkflowNotAlteredMixin,
 )
-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
 
 
 @dataclass(kw_only=True)
@@ -231,7 +235,7 @@ class SerializedFlowCommands:
         SerializedNodeCommands.NodeUUID, list[SerializedNodeCommands.IndirectSetParameterValueCommand]
     ]
     set_lock_commands_per_node: dict[SerializedNodeCommands.NodeUUID, SetLockNodeStateRequest]
-    sub_flows_commands: list["SerializedFlowCommands"]
+    sub_flows_commands: list[SerializedFlowCommands]
     node_dependencies: NodeDependencies
     node_types_used: set[LibraryNameAndNodeType]
 
@@ -386,63 +390,6 @@ class SetFlowMetadataResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure
     """Flow metadata update failed. Common causes: flow not found, no current context, invalid metadata."""
 
 
-@dataclass
-@PayloadRegistry.register
-class PackageNodeAsSerializedFlowRequest(RequestPayload):
-    """Package a single node as a complete flow with artificial start and end nodes.
-
-    Creates a serialized flow where:
-    - Start node has output parameters matching the packaged node's incoming connections
-    - End node has input parameters matching the packaged node's outgoing connections
-    - All connections are properly mapped through Start -> Node -> End
-
-    Use when: Creating reusable components, exporting nodes for templates,
-    building sub-workflows from existing nodes, creating packaged functionality.
-
-    Args:
-        node_name: Name of the node to package as a flow (None for current context node)
-        start_node_type: Node type name for the artificial start node (defaults to "StartFlow")
-        end_node_type: Node type name for the artificial end node (defaults to "EndFlow")
-        start_end_specific_library_name: Library name containing the start/end nodes (defaults to "Griptape Nodes Library")
-        entry_control_parameter_name: Name of the control parameter that the package node should be entered from. The generated start node will create a connection to this control parameter. NOTE: if no entry_control_parameter_name is specified, the package will be entered from the first available control input parameter.
-        output_parameter_prefix: Prefix for parameter names on the generated end node to avoid collisions (defaults to "packaged_node_")
-
-    Results: PackageNodeAsSerializedFlowResultSuccess (with serialized flow) | PackageNodeAsSerializedFlowResultFailure (node not found, packaging error)
-    """
-
-    # If None is passed, assumes we're packaging the node in the Current Context
-    node_name: str | None = None
-    start_node_type: str = "StartFlow"
-    end_node_type: str = "EndFlow"
-    start_end_specific_library_name: str = "Griptape Nodes Library"
-    entry_control_parameter_name: str | None = None
-    output_parameter_prefix: str = "packaged_node_"
-
-
-@dataclass
-@PayloadRegistry.register
-class PackageNodeAsSerializedFlowResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
-    """Node successfully packaged as serialized flow.
-
-    Args:
-        serialized_flow_commands: The complete serialized flow with StartFlow, target node, and EndFlow
-        workflow_shape: The workflow shape defining inputs and outputs for external callers
-    """
-
-    serialized_flow_commands: SerializedFlowCommands
-    workflow_shape: WorkflowShape
-
-
-@dataclass
-@PayloadRegistry.register
-class PackageNodeAsSerializedFlowResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
-    """Node packaging failed.
-
-    Common causes: node not found, no current context, serialization error,
-    connection analysis failed, node has no valid flow context.
-    """
-
-
 # Type aliases for parameter mapping clarity
 SanitizedParameterName = str  # What appears in the serialized flow
 OriginalNodeName = str  # Original node name (can have spaces, dots, etc.)
@@ -479,8 +426,8 @@ class PackageNodesAsSerializedFlowRequest(RequestPayload):
 
     Args:
         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 (defaults to "StartFlow")
-        end_node_type: Node type name for the artificial end node (defaults to "EndFlow")
+        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")
         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)
@@ -491,12 +438,15 @@ class PackageNodesAsSerializedFlowRequest(RequestPayload):
 
     # List of node names to package (empty list creates StartFlow→EndFlow only with warning)
     node_names: list[str] = field(default_factory=list)
-    start_node_type: str = "StartFlow"
-    end_node_type: str = "EndFlow"
+    start_node_type: str | None = None
+    end_node_type: str | None = None
     start_end_specific_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

griptape_nodes/retained_mode/events/parameter_events.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, NamedTuple
+from typing import TYPE_CHECKING, Any, NamedTuple
 
 from pydantic import Field
 
@@ -16,6 +16,11 @@ from griptape_nodes.retained_mode.events.base_events import (
 )
 from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from griptape_nodes.retained_mode.events.connection_events import IncomingConnection, OutgoingConnection
+
 
 @dataclass
 @PayloadRegistry.register
@@ -542,7 +547,123 @@ class RenameParameterResultFailure(ResultPayloadFailure):
     """
 
 
+@dataclass
+@PayloadRegistry.register
+class GetConnectionsForParameterRequest(RequestPayload):
+    """Get connections for a specific parameter on a node.
+
+    Use when: Checking if a parameter is connected, getting connection details for a parameter,
+    validating parameter connection state, building connection-aware UIs.
+
+    Args:
+        parameter_name: Name of the parameter to get connections for
+        node_name: Name of the node containing the parameter (None for current context)
+
+    Results: GetConnectionsForParameterResultSuccess (with connection details) | GetConnectionsForParameterResultFailure
+    """
+
+    parameter_name: str
+    # If node name is None, use the Current Context
+    node_name: str | None = None
+
+
+@dataclass
+@PayloadRegistry.register
+class GetConnectionsForParameterResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Parameter connections retrieved successfully.
+
+    Args:
+        parameter_name: Name of the parameter
+        node_name: Name of the node containing the parameter
+        incoming_connections: List of incoming connections to this parameter
+        outgoing_connections: List of outgoing connections from this parameter
+    """
+
+    parameter_name: str
+    node_name: str
+    incoming_connections: list[IncomingConnection]
+    outgoing_connections: list[OutgoingConnection]
+
+    def has_incoming_connections(self) -> bool:
+        """Check if the parameter has any incoming connections."""
+        return len(self.incoming_connections) > 0
+
+    def has_outgoing_connections(self) -> bool:
+        """Check if the parameter has any outgoing connections."""
+        return len(self.outgoing_connections) > 0
+
+
+@dataclass
+@PayloadRegistry.register
+class GetConnectionsForParameterResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Parameter connections retrieval failed. Common causes: node not found, parameter not found."""
+
+
 @dataclass
 @PayloadRegistry.register
 class RemoveElementEvent(ExecutionPayload):
     element_id: str
+
+
+# Migration Events
+@dataclass
+class ConversionConfig:
+    """Configuration for parameter conversion using intermediate nodes.
+
+    Args:
+        library: Library containing the conversion node type
+        node_type: Type of node to create for conversion
+        input_parameter: Parameter name on the conversion node to connect input to
+        output_parameter: Parameter name on the conversion node to connect output from
+        additional_parameters: Additional parameters to set on the conversion node
+        offset_side: Reference side/position from target node (defaults to "left" for input, "right" for output)
+        offset_x: X offset for positioning the conversion node relative to target node
+        offset_y: Y offset for positioning the conversion node relative to target node
+    """
+
+    library: str
+    node_type: str
+    input_parameter: str
+    output_parameter: str
+    additional_parameters: dict[str, Any] | None = None
+    offset_side: str | None = None
+    offset_x: int = 0
+    offset_y: int = 0
+
+
+@dataclass
+@PayloadRegistry.register
+class MigrateParameterRequest(RequestPayload):
+    """Request to migrate a parameter from one node to another with optional conversions.
+
+    Args:
+        source_node_name: Name of the source node
+        target_node_name: Name of the target node
+        source_parameter_name: Name of the parameter to migrate from
+        target_parameter_name: Name of the parameter to migrate to
+        input_conversion: Configuration for converting incoming connections
+        output_conversion: Configuration for converting outgoing connections
+        value_transform: Function to transform values when no connections exist
+        break_connections: If True, break any existing connections for the original parameter
+    """
+
+    source_node_name: str
+    target_node_name: str
+    source_parameter_name: str
+    target_parameter_name: str
+    input_conversion: ConversionConfig | None = None
+    output_conversion: ConversionConfig | None = None
+    value_transform: Callable | None = None
+    break_connections: bool = True
+
+
+@dataclass
+@PayloadRegistry.register
+class MigrateParameterResultSuccess(WorkflowAlteredMixin, ResultPayloadSuccess):
+    """Parameter migration completed successfully."""
+
+
+@dataclass
+@PayloadRegistry.register
+class MigrateParameterResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Parameter migration failed."""