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

griptape_nodes/bootstrap/utils/python_subprocess_executor.py

@@ -52,8 +52,8 @@ class PythonSubprocessExecutor:
 
             stdout_bytes, stderr_bytes = await self._process.communicate()
             returncode = self._process.returncode
-            stdout = stdout_bytes.decode() if stdout_bytes else ""
-            stderr = stderr_bytes.decode() if stderr_bytes else ""
+            stdout = stdout_bytes.decode(errors="replace") if stdout_bytes else ""
+            stderr = stderr_bytes.decode(errors="replace") if stderr_bytes else ""
 
             # Log all output regardless of return code
             if stdout:

griptape_nodes/bootstrap/workflow_executors/local_session_workflow_executor.py

@@ -109,7 +109,6 @@ class LocalSessionWorkflowExecutor(LocalWorkflowExecutor):
 
     async def arun(
         self,
-        workflow_name: str,
         flow_input: Any,
         storage_backend: StorageBackend | None = None,
         **kwargs: Any,
@@ -120,7 +119,6 @@ class LocalSessionWorkflowExecutor(LocalWorkflowExecutor):
         loading the user-defined workflow, and running the specified workflow.
 
         Parameters:
-            workflow_name: The name of the workflow to execute.
             flow_input: Input data for the flow, typically a dictionary.
             storage_backend: The storage backend to use for the workflow execution.
 
@@ -129,7 +127,6 @@ class LocalSessionWorkflowExecutor(LocalWorkflowExecutor):
         """
         try:
             await self._arun(
-                workflow_name=workflow_name,
                 flow_input=flow_input,
                 storage_backend=storage_backend,
                 **kwargs,
@@ -151,14 +148,12 @@ class LocalSessionWorkflowExecutor(LocalWorkflowExecutor):
 
     async def _arun(  # noqa: C901, PLR0915
         self,
-        workflow_name: str,
         flow_input: Any,
         storage_backend: StorageBackend | None = None,
         **kwargs: Any,
     ) -> None:
         """Internal async run method with detailed event handling and websocket integration."""
         flow_name = await self.aprepare_workflow_for_run(
-            workflow_name=workflow_name,
             flow_input=flow_input,
             storage_backend=storage_backend,
             **kwargs,

griptape_nodes/bootstrap/workflow_executors/local_workflow_executor.py

@@ -52,6 +52,15 @@ class LocalWorkflowExecutor(WorkflowExecutor):
         # TODO: Broadcast shutdown https://github.com/griptape-ai/griptape-nodes/issues/2149
         return
 
+    def _get_workflow_name(self) -> str:
+        try:
+            context_manager = GriptapeNodes.ContextManager()
+            return context_manager.get_current_workflow_name()
+        except Exception as e:
+            msg = f"Failed to get current workflow from context manager: {e}"
+            logger.exception(msg)
+            raise LocalExecutorError(msg) from e
+
     def _load_flow_for_workflow(self) -> str:
         try:
             context_manager = GriptapeNodes.ContextManager()
@@ -153,7 +162,6 @@ class LocalWorkflowExecutor(WorkflowExecutor):
 
     async def aprepare_workflow_for_run(
         self,
-        workflow_name: str,
         flow_input: Any,
         storage_backend: StorageBackend | None = None,
         **kwargs: Any,
@@ -164,7 +172,6 @@ class LocalWorkflowExecutor(WorkflowExecutor):
         initializing event listeners, registering libraries, loading the user-defined
         workflow, and preparing the specified workflow for execution.
         Parameters:
-            workflow_name: The name of the workflow to prepare.
             flow_input: Input data for the flow, typically a dictionary.
             storage_backend: The storage backend to use for the workflow execution.
 
@@ -175,7 +182,6 @@ class LocalWorkflowExecutor(WorkflowExecutor):
             msg = "The storage_backend parameter is deprecated. Pass `storage_backend` to the constructor instead."
             raise ValueError(msg)
 
-        logger.info("Executing workflow: %s", workflow_name)
         GriptapeNodes.EventManager().initialize_queue()
 
         # Load workflow from file if workflow_path is provided
@@ -192,7 +198,6 @@ class LocalWorkflowExecutor(WorkflowExecutor):
 
     async def arun(
         self,
-        workflow_name: str,
         flow_input: Any,
         storage_backend: StorageBackend | None = None,
         **kwargs: Any,
@@ -211,7 +216,6 @@ class LocalWorkflowExecutor(WorkflowExecutor):
             None
         """
         flow_name = await self.aprepare_workflow_for_run(
-            workflow_name=workflow_name,
             flow_input=flow_input,
             storage_backend=storage_backend,
             **kwargs,

griptape_nodes/bootstrap/workflow_executors/subprocess_workflow_executor.py

@@ -76,7 +76,6 @@ class SubprocessWorkflowExecutor(LocalSessionWorkflowExecutor, PythonSubprocessE
 
     async def arun(
         self,
-        workflow_name: str,  # noqa: ARG002
         flow_input: Any,
         storage_backend: StorageBackend = StorageBackend.LOCAL,
         *,

griptape_nodes/bootstrap/workflow_executors/workflow_executor.py

@@ -28,17 +28,15 @@ class WorkflowExecutor:
 
     def run(
         self,
-        workflow_name: str,
         flow_input: Any,
         storage_backend: StorageBackend = StorageBackend.LOCAL,
         **kwargs: Any,
     ) -> None:
-        return asyncio.run(self.arun(workflow_name, flow_input, storage_backend, **kwargs))
+        return asyncio.run(self.arun(flow_input, storage_backend, **kwargs))
 
     @abstractmethod
     async def arun(
         self,
-        workflow_name: str,
         flow_input: Any,
         storage_backend: StorageBackend = StorageBackend.LOCAL,
         **kwargs: Any,

griptape_nodes/bootstrap/workflow_publishers/local_workflow_publisher.py

@@ -27,7 +27,7 @@ class LocalWorkflowPublisher(LocalWorkflowExecutor):
         **kwargs: Any,
     ) -> None:
         # Load the workflow into memory
-        await self.aprepare_workflow_for_run(workflow_name=workflow_name, flow_input={}, workflow_path=workflow_path)
+        await self.aprepare_workflow_for_run(flow_input={}, workflow_path=workflow_path)
         pickle_control_flow_result = kwargs.get("pickle_control_flow_result", False)
         publish_workflow_request = PublishWorkflowRequest(
             workflow_name=workflow_name,

griptape_nodes/cli/commands/init.py

@@ -47,6 +47,13 @@ def init_command(  # noqa: PLR0913
             help="Install the Griptape Nodes Advanced Image Library.",
         ),
     ] = None,
+    register_griptape_cloud_library: Annotated[
+        bool | None,
+        typer.Option(
+            "--register-griptape-cloud-library/--no-register-griptape-cloud-library",
+            help="Install the Griptape Cloud Library.",
+        ),
+    ] = None,
     libraries_sync: Annotated[
         bool | None,
         typer.Option("--libraries-sync/--no-libraries-sync", help="Sync the Griptape Nodes libraries."),
@@ -83,6 +90,7 @@ def init_command(  # noqa: PLR0913
             api_key=api_key,
             storage_backend=storage_backend,
             register_advanced_library=register_advanced_library,
+            register_griptape_cloud_library=register_griptape_cloud_library,
             config_values=config_values,
             secret_values=secret_values,
             libraries_sync=libraries_sync,
@@ -134,7 +142,7 @@ def _run_init_configuration(config: InitConfig) -> None:
     _handle_storage_backend_config(config)
     _handle_bucket_config(config)
     _handle_hf_token_config(config)
-    _handle_advanced_library_config(config)
+    _handle_additional_library_config(config)
     _handle_arbitrary_configs(config)
 
 
@@ -218,17 +226,24 @@ def _handle_hf_token_config(config: InitConfig) -> str | None:
     return hf_token
 
 
-def _handle_advanced_library_config(config: InitConfig) -> bool | None:
-    """Handle advanced library configuration step."""
+def _handle_additional_library_config(config: InitConfig) -> bool | None:
+    """Handle additional library configuration step."""
     register_advanced_library = config.register_advanced_library
+    register_griptape_cloud_library = config.register_griptape_cloud_library
 
     if config.interactive:
         register_advanced_library = _prompt_for_advanced_media_library(
             default_prompt_for_advanced_media_library=register_advanced_library
         )
+        register_griptape_cloud_library = _prompt_for_griptape_cloud_library(
+            default_prompt_for_griptape_cloud_library=register_griptape_cloud_library
+        )
 
-    if register_advanced_library is not None:
-        libraries_to_register = _build_libraries_list(register_advanced_library=register_advanced_library)
+    if register_advanced_library is not None or register_griptape_cloud_library is not None:
+        libraries_to_register = _build_libraries_list(
+            register_advanced_library=register_advanced_library,
+            register_griptape_cloud_library=register_griptape_cloud_library,
+        )
         config_manager.set_config_value(
             "app_events.on_app_initialization_complete.libraries_to_register", libraries_to_register
         )
@@ -470,8 +485,25 @@ def _prompt_for_advanced_media_library(*, default_prompt_for_advanced_media_libr
     return Confirm.ask("Register Advanced Media Library?", default=default_prompt_for_advanced_media_library)
 
 
-def _build_libraries_list(*, register_advanced_library: bool) -> list[str]:
-    """Builds the list of libraries to register based on the advanced library setting."""
+def _prompt_for_griptape_cloud_library(*, default_prompt_for_griptape_cloud_library: bool | None = None) -> bool:
+    """Prompts the user whether to register the Griptape Cloud Library."""
+    if default_prompt_for_griptape_cloud_library is None:
+        default_prompt_for_griptape_cloud_library = False
+    explainer = """[bold cyan]Griptape Cloud Library[/bold cyan]
+    Would you like to install the Griptape Nodes Griptape Cloud Library?
+    This node library makes Griptape Cloud APIs and functionality available within Griptape Nodes.
+    For example, nodes are available for invoking Structures, Assistants, or even publishing a Workflow to Griptape Cloud.
+    The Griptape Nodes Griptape Cloud Library can be added later by following instructions here: [bold blue][link=https://docs.griptapenodes.com]https://docs.griptapenodes.com[/link][/bold blue].
+    """
+    console.print(Panel(explainer, expand=False))
+
+    return Confirm.ask("Register Griptape Cloud Library?", default=default_prompt_for_griptape_cloud_library)
+
+
+def _build_libraries_list(
+    *, register_advanced_library: bool | None = False, register_griptape_cloud_library: bool | None = False
+) -> list[str]:
+    """Builds the list of libraries to register based on library settings."""
     # TODO: https://github.com/griptape-ai/griptape-nodes/issues/929
     libraries_key = "app_events.on_app_initialization_complete.libraries_to_register"
     library_base_dir = Path(ENV_LIBRARIES_BASE_DIR)
@@ -509,6 +541,20 @@ def _build_libraries_list(*, register_advanced_library: bool) -> list[str]:
         for lib in libraries_to_remove:
             new_libraries.remove(lib)
 
+    griptape_cloud_library = str(library_base_dir / "griptape_cloud/griptape_nodes_library.json")
+    griptape_cloud_identifier = _get_library_identifier(griptape_cloud_library)
+    if register_griptape_cloud_library:
+        # If the griptape cloud library is not registered, add it
+        if griptape_cloud_identifier not in current_identifiers:
+            new_libraries.append(griptape_cloud_library)
+    else:
+        # If the griptape cloud library is registered, remove it
+        libraries_to_remove = [
+            lib for lib in new_libraries if _get_library_identifier(lib) == griptape_cloud_identifier
+        ]
+        for lib in libraries_to_remove:
+            new_libraries.remove(lib)
+
     return new_libraries
 
 

griptape_nodes/cli/shared.py

@@ -18,6 +18,7 @@ class InitConfig:
     api_key: str | None = None
     storage_backend: str | None = None
     register_advanced_library: bool | None = None
+    register_griptape_cloud_library: bool | None = None
     config_values: dict[str, Any] | None = None
     secret_values: dict[str, str] | None = None
     libraries_sync: bool | None = None

griptape_nodes/common/node_executor.py

@@ -13,14 +13,17 @@ from griptape_nodes.exe_types.node_types import (
     CONTROL_INPUT_PARAMETER,
     LOCAL_EXECUTION,
     PRIVATE_EXECUTION,
+    BaseNode,
     EndNode,
+    NodeGroup,
+    NodeGroupProxyNode,
     StartNode,
 )
 from griptape_nodes.node_library.library_registry import Library, LibraryRegistry
 from griptape_nodes.node_library.workflow_registry import WorkflowRegistry
 from griptape_nodes.retained_mode.events.flow_events import (
-    PackageNodeAsSerializedFlowRequest,
-    PackageNodeAsSerializedFlowResultSuccess,
+    PackageNodesAsSerializedFlowRequest,
+    PackageNodesAsSerializedFlowResultSuccess,
 )
 from griptape_nodes.retained_mode.events.workflow_events import (
     DeleteWorkflowRequest,
@@ -34,7 +37,7 @@ from griptape_nodes.retained_mode.events.workflow_events import (
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 
 if TYPE_CHECKING:
-    from griptape_nodes.exe_types.node_types import BaseNode
+    from griptape_nodes.exe_types.connections import Connections
     from griptape_nodes.retained_mode.events.node_events import SerializedNodeCommands
     from griptape_nodes.retained_mode.managers.library_manager import LibraryManager
 
@@ -47,6 +50,7 @@ class PublishLocalWorkflowResult(NamedTuple):
     workflow_result: SaveWorkflowFileFromSerializedFlowResultSuccess
     file_name: str
     output_parameter_prefix: str
+    package_result: PackageNodesAsSerializedFlowResultSuccess
 
 
 class NodeExecutor:
@@ -69,6 +73,7 @@ class NodeExecutor:
             library_name: The library that the execute method should come from.
         """
         execution_type = node.get_parameter_value(node.execution_environment.name)
+
         if execution_type == LOCAL_EXECUTION:
             await node.aprocess()
         elif execution_type == PRIVATE_EXECUTION:
@@ -81,7 +86,7 @@ class NodeExecutor:
         node: BaseNode,
         workflow_path: Path,
         file_name: str,
-        output_parameter_prefix: str,
+        package_result: PackageNodesAsSerializedFlowResultSuccess,
     ) -> None:
         """Execute workflow in subprocess and apply results to node.
 
@@ -89,11 +94,11 @@ class NodeExecutor:
             node: The node to apply results to
             workflow_path: Path to workflow file to execute
             file_name: Name of workflow for logging
-            output_parameter_prefix: Prefix for output parameters
+            package_result: The packaging result containing parameter mappings
         """
         my_subprocess_result = await self._execute_subprocess(workflow_path, file_name)
         parameter_output_values = self._extract_parameter_output_values(my_subprocess_result)
-        self._apply_parameter_values_to_node(node, parameter_output_values, output_parameter_prefix)
+        self._apply_parameter_values_to_node(node, parameter_output_values, package_result)
 
     async def _execute_private_workflow(self, node: BaseNode) -> None:
         """Execute node in private subprocess environment.
@@ -116,7 +121,10 @@ class NodeExecutor:
 
         try:
             await self._execute_and_apply_workflow(
-                node, Path(workflow_result.file_path), result.file_name, result.output_parameter_prefix
+                node=node,
+                workflow_path=Path(workflow_result.file_path),
+                file_name=result.file_name,
+                package_result=result.package_result,
             )
         except RuntimeError:
             raise
@@ -188,7 +196,10 @@ class NodeExecutor:
 
         try:
             await self._execute_and_apply_workflow(
-                node, published_workflow_filename, result.file_name, result.output_parameter_prefix
+                node,
+                published_workflow_filename,
+                result.file_name,
+                result.package_result,
             )
         except RuntimeError:
             raise
@@ -220,7 +231,7 @@ class NodeExecutor:
         """
         sanitized_node_name = node.name.replace(" ", "_")
         output_parameter_prefix = f"{sanitized_node_name}_packaged_node_"
-        # We have to make our defaults strings because the PackageNodeAsSerializedFlowRequest doesn't accept None types.
+        # We have to make our defaults strings because the PackageNodesAsSerializedFlowRequest doesn't accept None types.
         library_name = "Griptape Nodes Library"
         start_node_type = "StartFlow"
         end_node_type = "EndFlow"
@@ -232,19 +243,28 @@ class NodeExecutor:
                 end_node_type = end_nodes[0]
                 library_name = library.get_library_data().name
         sanitized_library_name = library_name.replace(" ", "_")
-        request = PackageNodeAsSerializedFlowRequest(
-            node_name=node.name,
+        # If we are packaging a NodeGroupProxyNode, that means that we are packaging multiple nodes together, so we have to get the list of nodes from the proxy node.
+        if isinstance(node, NodeGroupProxyNode):
+            node_names = list(node.node_group_data.nodes.keys())
+        else:
+            # Otherwise, it's a list of one node!
+            node_names = [node.name]
+
+        # Pass the proxy node if this is a NodeGroupProxyNode so serialization can use stored connections
+        proxy_node_for_packaging = node if isinstance(node, NodeGroupProxyNode) else None
+
+        request = PackageNodesAsSerializedFlowRequest(
+            node_names=node_names,
             start_node_type=start_node_type,
             end_node_type=end_node_type,
             start_end_specific_library_name=library_name,
-            entry_control_parameter_name=node._entry_control_parameter.name
-            if node._entry_control_parameter is not None
-            else None,
             output_parameter_prefix=output_parameter_prefix,
+            entry_control_node_name=None,
+            entry_control_parameter_name=None,
+            proxy_node=proxy_node_for_packaging,
         )
-
         package_result = GriptapeNodes.handle_request(request)
-        if not isinstance(package_result, PackageNodeAsSerializedFlowResultSuccess):
+        if not isinstance(package_result, PackageNodesAsSerializedFlowResultSuccess):
             msg = f"Failed to package node '{node.name}'. Error: {package_result.result_details}"
             raise RuntimeError(msg)  # noqa: TRY004
 
@@ -262,7 +282,10 @@ class NodeExecutor:
             raise RuntimeError(msg)  # noqa: TRY004
 
         return PublishLocalWorkflowResult(
-            workflow_result=workflow_result, file_name=file_name, output_parameter_prefix=output_parameter_prefix
+            workflow_result=workflow_result,
+            file_name=file_name,
+            output_parameter_prefix=output_parameter_prefix,
+            package_result=package_result,
         )
 
     async def _publish_library_workflow(
@@ -311,7 +334,6 @@ class NodeExecutor:
         try:
             async with subprocess_executor as executor:
                 await executor.arun(
-                    workflow_name=file_name,
                     flow_input={},
                     storage_backend=await self._get_storage_backend(),
                     pickle_control_flow_result=pickle_control_flow_result,
@@ -398,38 +420,78 @@ class NodeExecutor:
             return stored_value
         return stored_value
 
-    def _apply_parameter_values_to_node(
-        self, node: BaseNode, parameter_output_values: dict[str, Any], output_parameter_prefix: str
+    def _apply_parameter_values_to_node(  # noqa: C901
+        self,
+        node: BaseNode,
+        parameter_output_values: dict[str, Any],
+        package_result: PackageNodesAsSerializedFlowResultSuccess,
     ) -> None:
         """Apply deserialized parameter values back to the node.
 
         Sets parameter values on the node and updates parameter_output_values dictionary.
+        Uses parameter_name_mappings from package_result to map packaged parameters back to original nodes.
+        Works for both single-node and multi-node packages.
         """
-        # If the packaged flow fails, the End Flow Node in the library published workflow will have entered from 'failed'. That means that running the node failed, but was caught by the published flow.
-        # In this case, we should fail the node, since it didn't complete properly.
+        # If the packaged flow fails, the End Flow Node in the library published workflow will have entered from 'failed'
         if "failed" in parameter_output_values and parameter_output_values["failed"] == CONTROL_INPUT_PARAMETER:
             msg = f"Failed to execute node: {node.name}, with exception: {parameter_output_values.get('result_details', 'No result details were returned.')}"
             raise RuntimeError(msg)
+
+        # Use parameter mappings to apply values back to original nodes
+        parameter_name_mappings = package_result.parameter_name_mappings
         for param_name, param_value in parameter_output_values.items():
-            # We are grabbing all of the parameters on our end nodes that align with the node being published.
-            if param_name.startswith(output_parameter_prefix):
-                clean_param_name = param_name[len(output_parameter_prefix) :]
-                # If the parameter exists on the node, then we need to set those values on the node.
-                parameter = node.get_parameter_by_name(clean_param_name)
-                # Don't set execution_environment, since that will be set to Local Execution on any published flow.
-                if parameter is None:
-                    msg = (
-                        "Parameter '%s' from parameter output values not found on node '%s'",
-                        clean_param_name,
-                        node.name,
-                    )
-                    logger.error(msg)
+            # Check if this parameter has a mapping back to an original node parameter
+            if param_name not in parameter_name_mappings:
+                continue
+
+            original_node_param = parameter_name_mappings[param_name]
+            target_node_name = original_node_param.node_name
+            target_param_name = original_node_param.parameter_name
+
+            # For multi-node packages, get the target node from the group
+            # For single-node packages, use the node itself
+            if isinstance(node, NodeGroupProxyNode):
+                if target_node_name not in node.node_group_data.nodes:
+                    msg = f"Target node '{target_node_name}' not found in node group for proxy node '{node.name}'. Available nodes: {list(node.node_group_data.nodes.keys())}"
                     raise RuntimeError(msg)
-                if parameter != node.execution_environment:
-                    if parameter.type != ParameterTypeBuiltin.CONTROL_TYPE:
-                        # If the node is control type, only set its value in parameter_output_values.
-                        node.set_parameter_value(clean_param_name, param_value)
-                    node.parameter_output_values[clean_param_name] = param_value
+                target_node = node.node_group_data.nodes[target_node_name]
+            else:
+                target_node = node
+
+            # Get the parameter from the target node
+            target_param = target_node.get_parameter_by_name(target_param_name)
+
+            # Skip if parameter not found or is special parameter (execution_environment, node_group)
+            if target_param is None or target_param in (
+                target_node.execution_environment,
+                target_node.node_group,
+            ):
+                logger.debug(
+                    "Skipping special or missing parameter '%s' on node '%s'", target_param_name, target_node_name
+                )
+                continue
+
+            # Set the value on the target node
+            if target_param.type != ParameterTypeBuiltin.CONTROL_TYPE:
+                target_node.set_parameter_value(target_param_name, param_value)
+            target_node.parameter_output_values[target_param_name] = param_value
+
+            # For multi-node packages, also set the value on the proxy node's corresponding output parameter
+            if isinstance(node, NodeGroupProxyNode):
+                sanitized_node_name = target_node_name.replace(" ", "_")
+                proxy_param_name = f"{sanitized_node_name}__{target_param_name}"
+                proxy_param = node.get_parameter_by_name(proxy_param_name)
+                if proxy_param is not None:
+                    if target_param.type != ParameterTypeBuiltin.CONTROL_TYPE:
+                        node.set_parameter_value(proxy_param_name, param_value)
+                    node.parameter_output_values[proxy_param_name] = param_value
+
+            logger.debug(
+                "Set parameter '%s' on node '%s' to value: %s",
+                target_param_name,
+                target_node_name,
+                param_value,
+            )
 
     async def _delete_workflow(self, workflow_name: str, workflow_path: Path) -> None:
         try:
@@ -464,3 +526,117 @@ class NodeExecutor:
         except ValueError:
             storage_backend = StorageBackend.LOCAL
         return storage_backend
+
+    def _toggle_directional_control_connections(
+        self,
+        proxy_node: BaseNode,
+        node_group: NodeGroup,
+        connections: Connections,
+        *,
+        restore_to_original: bool,
+        is_incoming: bool,
+    ) -> None:
+        """Toggle control connections between proxy and original nodes for a specific direction.
+
+        When a NodeGroupProxyNode is created, control connections from/to the original nodes are
+        redirected to/from the proxy node. Before packaging the flow for execution, we need to
+        temporarily restore these connections back to the original nodes so the packaged flow
+        has the correct control flow structure. After packaging, we toggle them back to the proxy.
+
+        Args:
+            proxy_node: The proxy node containing the node group
+            node_group: The node group data containing original nodes and connection mappings
+            connections: The connections manager that tracks all connections via indexes
+            restore_to_original: If True, restore connections to original nodes (for packaging);
+                               if False, remap connections to proxy (after packaging)
+            is_incoming: If True, handle incoming connections (target_node/target_parameter);
+                        if False, handle outgoing connections (source_node/source_parameter)
+        """
+        # Select the appropriate connection list, mapping, and index based on direction
+        if is_incoming:
+            # Incoming: connections pointing TO nodes in this group
+            connection_list = node_group.external_incoming_connections
+            original_nodes_map = node_group.original_incoming_targets
+            index = connections.incoming_index
+        else:
+            # Outgoing: connections originating FROM nodes in this group
+            connection_list = node_group.external_outgoing_connections
+            original_nodes_map = node_group.original_outgoing_sources
+            index = connections.outgoing_index
+
+        for conn in connection_list:
+            # Get the parameter based on connection direction (target for incoming, source for outgoing)
+            parameter = conn.target_parameter if is_incoming else conn.source_parameter
+
+            # Only toggle control flow connections, skip data connections
+            if parameter.type != ParameterTypeBuiltin.CONTROL_TYPE:
+                continue
+
+            conn_id = id(conn)
+            original_node = original_nodes_map.get(conn_id)
+
+            # Validate we have the original node mapping
+            # Incoming connections must have originals (error if missing)
+            # Outgoing connections may not have originals in some cases (skip if missing)
+            if original_node is None:
+                if is_incoming:
+                    msg = f"No original target found for connection {conn_id} in node group '{node_group.group_id}'"
+                    raise RuntimeError(msg)
+                continue
+
+            # Build the proxy parameter name: {sanitized_node_name}__{parameter_name}
+            # Example: "My Node" with param "enter" -> "My_Node__enter"
+            sanitized_node_name = original_node.name.replace(" ", "_")
+            proxy_param_name = f"{sanitized_node_name}__{parameter.name}"
+
+            # Determine the direction of the toggle
+            if restore_to_original:
+                # Restore: proxy -> original (for packaging)
+                # Before: External -> Proxy -> (internal nodes)
+                # After:  External -> Original node in group
+                from_node = proxy_node
+                from_param = proxy_param_name
+                to_node = original_node
+                to_param = parameter.name
+            else:
+                # Remap: original -> proxy (after packaging)
+                # Before: External -> Original node in group
+                # After:  External -> Proxy -> (internal nodes)
+                from_node = original_node
+                from_param = parameter.name
+                to_node = proxy_node
+                to_param = proxy_param_name
+
+            # Step 1: Remove connection reference from the old node's index
+            if from_node.name in index and from_param in index[from_node.name]:
+                index[from_node.name][from_param].remove(conn_id)
+
+            # Step 2: Update the connection object to point to the new node
+            if is_incoming:
+                conn.target_node = to_node
+            else:
+                conn.source_node = to_node
+
+            # Step 3: Add connection reference to the new node's index
+            index.setdefault(to_node.name, {}).setdefault(to_param, []).append(conn_id)
+
+    def _toggle_control_connections(self, proxy_node: BaseNode, *, restore_to_original: bool) -> None:
+        """Toggle control connections between proxy node and original nodes.
+
+        Args:
+            proxy_node: The proxy node containing the node group
+            restore_to_original: If True, restore connections from proxy to original nodes.
+                               If False, remap connections from original nodes back to proxy.
+        """
+        if not isinstance(proxy_node, NodeGroupProxyNode):
+            return
+        node_group = proxy_node.node_group_data
+        connections = GriptapeNodes.FlowManager().get_connections()
+
+        # Toggle both incoming and outgoing connections
+        self._toggle_directional_control_connections(
+            proxy_node, node_group, connections, restore_to_original=restore_to_original, is_incoming=True
+        )
+        self._toggle_directional_control_connections(
+            proxy_node, node_group, connections, restore_to_original=restore_to_original, is_incoming=False
+        )