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

griptape_nodes/retained_mode/managers/flow_manager.py

@@ -15,7 +15,15 @@ from griptape_nodes.exe_types.core_types import (
     ParameterTypeBuiltin,
 )
 from griptape_nodes.exe_types.flow import ControlFlow
-from griptape_nodes.exe_types.node_types import BaseNode, ErrorProxyNode, NodeResolutionState, StartLoopNode, StartNode
+from griptape_nodes.exe_types.node_types import (
+    LOCAL_EXECUTION,
+    BaseNode,
+    ErrorProxyNode,
+    NodeDependencies,
+    NodeResolutionState,
+    StartLoopNode,
+    StartNode,
+)
 from griptape_nodes.machines.control_flow import CompleteState, ControlFlowMachine
 from griptape_nodes.machines.dag_builder import DagBuilder
 from griptape_nodes.machines.parallel_resolution import ParallelResolutionMachine
@@ -1090,15 +1098,20 @@ class FlowManager:
         # Step 4: Serialize the package node
         unique_parameter_uuid_to_values = {}
         serialized_parameter_value_tracker = SerializedParameterValueTracker()
+        package_node = package_node_info.package_node
+        # Set to LOCAL_EXECUTION before packaging to prevent recursive loop.
+        previous_value = package_node.get_parameter_value("execution_environment")
+        package_node.set_parameter_value("execution_environment", LOCAL_EXECUTION)
         serialized_package_result = self._serialize_package_node(
             node_name=package_node_info.package_node.name,
             package_node=package_node_info.package_node,
             unique_parameter_uuid_to_values=unique_parameter_uuid_to_values,
             serialized_parameter_value_tracker=serialized_parameter_value_tracker,
         )
+        # Now that we've serialized the value as LOCAL_EXECUTION, we need to restore it to whatever it was before
+        package_node.set_parameter_value("execution_environment", previous_value)
         if isinstance(serialized_package_result, PackageNodeAsSerializedFlowResultFailure):
             return serialized_package_result
-
         # Step 5: Create start node commands and data connections
         start_node_result = self._create_start_node_commands(
             request=request,
@@ -1152,7 +1165,6 @@ class FlowManager:
         workflow_shape = GriptapeNodes.WorkflowManager().build_workflow_shape_from_parameter_info(
             input_node_params=start_node_result.input_shape_data, output_node_params=end_node_result.output_shape_data
         )
-
         # Return success result
         return PackageNodeAsSerializedFlowResultSuccess(
             result_details=f'Successfully packaged node "{package_node_info.package_node.name}" from flow "{package_node_info.package_flow_name}" as serialized flow with start node type "{request.start_node_type}" and end node type "{request.end_node_type}" from library "{request.start_end_specific_library_name}".',
@@ -1428,10 +1440,13 @@ class FlowManager:
             start_to_package_data_connections.append(start_to_package_connection)
 
         # Build complete SerializedNodeCommands for start node
+        start_node_dependencies = NodeDependencies()
+        start_node_dependencies.libraries.add(start_node_library_details)
+
         start_node_commands = SerializedNodeCommands(
             create_node_command=start_create_node_command,
             element_modification_commands=start_node_parameter_commands,
-            node_library_details=start_node_library_details,
+            node_dependencies=start_node_dependencies,
             node_uuid=start_node_uuid,
         )
 
@@ -1519,10 +1534,13 @@ class FlowManager:
             package_to_end_data_connections.append(package_to_end_connection)
 
         # Build complete SerializedNodeCommands for end node
+        end_node_dependencies = NodeDependencies()
+        end_node_dependencies.libraries.add(end_node_library_details)
+
         end_node_commands = SerializedNodeCommands(
             create_node_command=end_create_node_command,
             element_modification_commands=end_node_parameter_commands,
-            node_library_details=end_node_library_details,
+            node_dependencies=end_node_dependencies,
             node_uuid=end_node_uuid,
         )
 
@@ -1601,18 +1619,6 @@ class FlowManager:
                 serialized_package_result.serialized_node_commands.lock_node_command
             )
 
-        # Collect all libraries used
-        end_node_library_details = LibraryNameAndVersion(
-            library_name=request.start_end_specific_library_name,
-            library_version=library_version,
-        )
-
-        node_libraries_used = {
-            serialized_package_result.serialized_node_commands.node_library_details,
-            start_node_result.start_node_commands.node_library_details,
-            end_node_library_details,
-        }
-
         # Include all three nodes in the flow
         all_serialized_nodes = [
             start_node_result.start_node_commands,
@@ -1634,9 +1640,18 @@ class FlowManager:
             metadata=packaged_flow_metadata,
         )
 
+        # Aggregate dependencies from the packaged nodes
+        packaged_dependencies = self._aggregate_flow_dependencies(all_serialized_nodes, [])
+
+        # Add the start/end specific library dependency
+        start_end_library_dependency = LibraryNameAndVersion(
+            library_name=request.start_end_specific_library_name,
+            library_version=library_version,
+        )
+        packaged_dependencies.libraries.add(start_end_library_dependency)
+
         # Build the complete SerializedFlowCommands
         return SerializedFlowCommands(
-            node_libraries_used=node_libraries_used,
             flow_initialization_command=create_packaged_flow_request,
             serialized_node_commands=all_serialized_nodes,
             serialized_connections=all_connections,
@@ -1647,7 +1662,7 @@ class FlowManager:
             },
             set_lock_commands_per_node=set_lock_commands_per_node,
             sub_flows_commands=[],
-            referenced_workflows=set(),
+            node_dependencies=packaged_dependencies,
         )
 
     async def on_start_flow_request(self, request: StartFlowRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912
@@ -1901,6 +1916,31 @@ class FlowManager:
 
         return ListFlowsInCurrentContextResultSuccess(flow_names=ret_list, result_details=details)
 
+    def _aggregate_flow_dependencies(
+        self, serialized_node_commands: list[SerializedNodeCommands], sub_flows_commands: list[SerializedFlowCommands]
+    ) -> NodeDependencies:
+        """Aggregate dependencies from nodes and sub-flows into a single NodeDependencies object.
+
+        Args:
+            serialized_node_commands: List of serialized node commands to aggregate from
+            sub_flows_commands: List of sub-flow commands to aggregate from
+
+        Returns:
+            NodeDependencies object with all dependencies merged
+        """
+        # Start with empty dependencies and aggregate into it
+        aggregated_deps = NodeDependencies()
+
+        # Aggregate dependencies from all nodes
+        for node_cmd in serialized_node_commands:
+            aggregated_deps.aggregate_from(node_cmd.node_dependencies)
+
+        # Aggregate dependencies from all sub-flows
+        for sub_flow_cmd in sub_flows_commands:
+            aggregated_deps.aggregate_from(sub_flow_cmd.node_dependencies)
+
+        return aggregated_deps
+
     # TODO: https://github.com/griptape-ai/griptape-nodes/issues/861
     # similar manager refactors: https://github.com/griptape-ai/griptape-nodes/issues/806
     def on_serialize_flow_to_commands(self, request: SerializeFlowToCommandsRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912, PLR0915
@@ -1922,12 +1962,6 @@ class FlowManager:
                 )
                 return SerializeFlowToCommandsResultFailure(result_details=details)
 
-        # Track all node libraries that were in use by these Nodes
-        node_libraries_in_use = set()
-
-        # Track all referenced workflows used by this flow and its sub-flows
-        referenced_workflows_in_use = set()
-
         # Track all parameter values that were in use by these Nodes (maps UUID to Parameter value)
         unique_parameter_uuid_to_values = {}
         # And track how values map into that map.
@@ -1943,7 +1977,6 @@ class FlowManager:
                         workflow_name=referenced_workflow_name,  # type: ignore[arg-type] # is_referenced_workflow() guarantees this is not None
                         imported_flow_metadata=flow.metadata,
                     )
-                    referenced_workflows_in_use.add(referenced_workflow_name)  # type: ignore[arg-type] # is_referenced_workflow() guarantees this is not None
                 else:
                     # Always set set_as_new_context=False during serialization - let the workflow manager
                     # that loads this serialized flow decide whether to push it to context or not
@@ -1991,7 +2024,6 @@ class FlowManager:
                     node_name_to_uuid[node_name] = serialized_node.node_uuid
 
                     serialized_node_commands.append(serialized_node)
-                    node_libraries_in_use.add(serialized_node.node_library_details)
                     # Get the list of set value commands for THIS node.
                     set_value_commands_list = serialize_node_result.set_parameter_value_commands
                     if serialize_node_result.serialized_node_commands.lock_node_command is not None:
@@ -2040,20 +2072,22 @@ class FlowManager:
                         imported_flow_metadata=flow.metadata,
                     )
 
+                    # Create NodeDependencies with just the referenced workflow
+                    sub_flow_dependencies = NodeDependencies(
+                        referenced_workflows={referenced_workflow_name}  # type: ignore[arg-type] # is_referenced_workflow() guarantees this is not None
+                    )
+
                     serialized_flow = SerializedFlowCommands(
-                        node_libraries_used=set(),
                         flow_initialization_command=import_command,
                         serialized_node_commands=[],
                         serialized_connections=[],
                         unique_parameter_uuid_to_values={},
                         set_parameter_value_commands={},
+                        set_lock_commands_per_node={},
                         sub_flows_commands=[],
-                        referenced_workflows={referenced_workflow_name},  # type: ignore[arg-type] # is_referenced_workflow() guarantees this is not None
+                        node_dependencies=sub_flow_dependencies,
                     )
                     sub_flow_commands.append(serialized_flow)
-
-                    # Add this referenced workflow to our accumulation
-                    referenced_workflows_in_use.add(referenced_workflow_name)  # type: ignore[arg-type] # is_referenced_workflow() guarantees this is not None
                 else:
                     # For standalone sub-flows, use the existing recursive serialization
                     with GriptapeNodes.ContextManager().flow(flow=flow):
@@ -2065,11 +2099,8 @@ class FlowManager:
                         serialized_flow = child_flow_result.serialized_flow_commands
                         sub_flow_commands.append(serialized_flow)
 
-                        # Merge in all child flow library details.
-                        node_libraries_in_use.union(serialized_flow.node_libraries_used)
-
-                        # Merge in all child flow referenced workflows.
-                        referenced_workflows_in_use.union(serialized_flow.referenced_workflows)
+        # Aggregate all dependencies from nodes and sub-flows
+        aggregated_dependencies = self._aggregate_flow_dependencies(serialized_node_commands, sub_flow_commands)
 
         serialized_flow = SerializedFlowCommands(
             flow_initialization_command=create_flow_request,
@@ -2079,8 +2110,7 @@ class FlowManager:
             set_parameter_value_commands=set_parameter_value_commands_per_node,
             set_lock_commands_per_node=set_lock_commands_per_node,
             sub_flows_commands=sub_flow_commands,
-            node_libraries_used=node_libraries_in_use,
-            referenced_workflows=referenced_workflows_in_use,
+            node_dependencies=aggregated_dependencies,
         )
         details = f"Successfully serialized Flow '{flow_name}' into commands."
         result = SerializeFlowToCommandsResultSuccess(serialized_flow_commands=serialized_flow, result_details=details)
@@ -2280,6 +2310,9 @@ class FlowManager:
         self._global_dag_builder.clear()
         logger.debug("Cancelling flow run")
 
+        GriptapeNodes.EventManager().put_event(
+            ExecutionGriptapeNodeEvent(wrapped_event=ExecutionEvent(payload=InvolvedNodesEvent(involved_nodes=[])))
+        )
         GriptapeNodes.EventManager().put_event(
             ExecutionGriptapeNodeEvent(wrapped_event=ExecutionEvent(payload=ControlFlowCancelledEvent()))
         )
@@ -2394,17 +2427,16 @@ class FlowManager:
             try:
                 await resolution_machine.resolve_node(node)
             except Exception as e:
+                logger.exception("Exception during single node resolution")
                 if self.check_for_existing_running_flow():
                     self.cancel_flow_run()
                     raise RuntimeError(e) from e
             if resolution_machine.is_complete():
                 self._global_single_node_resolution = False
                 self._global_control_flow_machine.context.current_nodes = []
-                GriptapeNodes.EventManager().put_event(
-                    ExecutionGriptapeNodeEvent(
-                        wrapped_event=ExecutionEvent(payload=InvolvedNodesEvent(involved_nodes=[]))
-                    )
-                )
+            GriptapeNodes.EventManager().put_event(
+                ExecutionGriptapeNodeEvent(wrapped_event=ExecutionEvent(payload=InvolvedNodesEvent(involved_nodes=[])))
+            )
 
     async def single_execution_step(self, flow: ControlFlow, change_debug_mode: bool) -> None:  # noqa: FBT001
         # do a granular step

griptape_nodes/retained_mode/managers/library_manager.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import importlib.util
 import json
 import logging
@@ -895,7 +896,8 @@ class LibraryManager:
                         continue  # SKIP IT
 
         # Attempt to load nodes from the library.
-        library_load_results = self._attempt_load_nodes_from_library(
+        library_load_results = await asyncio.to_thread(
+            self._attempt_load_nodes_from_library,
             library_data=library_data,
             library=library,
             base_dir=base_dir,
@@ -1521,7 +1523,7 @@ class LibraryManager:
         for library_result in metadata_result.successful_libraries:
             if library_result.library_schema.name == LibraryManager.SANDBOX_LIBRARY_NAME:
                 # Handle sandbox library - use the schema we already have
-                self._attempt_generate_sandbox_library_from_schema(
+                await self._attempt_generate_sandbox_library_from_schema(
                     library_schema=library_result.library_schema, sandbox_directory=library_result.file_path
                 )
             else:
@@ -1853,7 +1855,7 @@ class LibraryManager:
             problems=problems,
         )
 
-    def _attempt_generate_sandbox_library_from_schema(
+    async def _attempt_generate_sandbox_library_from_schema(
         self, library_schema: LibrarySchema, sandbox_directory: str
     ) -> None:
         """Generate sandbox library using an existing schema, loading actual node classes."""
@@ -1945,7 +1947,8 @@ class LibraryManager:
             return
 
         # Load nodes into the library
-        library_load_results = self._attempt_load_nodes_from_library(
+        library_load_results = await asyncio.to_thread(
+            self._attempt_load_nodes_from_library,
             library_data=library_data,
             library=library,
             base_dir=sandbox_library_dir,
@@ -2058,9 +2061,4 @@ class LibraryManager:
             if library_path.exists():
                 process_path(library_path)
 
-        # Add from workspace - recursive discovery of library JSON files
-        workspace_path = config_mgr.workspace_path
-        if workspace_path.exists():
-            process_path(workspace_path)
-
         return list(discovered_libraries)

griptape_nodes/retained_mode/managers/mcp_manager.py

@@ -0,0 +1,364 @@
+"""MCP (Model Context Protocol) server management.
+
+Handles MCP server configurations, enabling/disabling servers, and provides
+event-based interface for frontend and backend interactions.
+"""
+
+import logging
+from typing import Any
+
+from griptape_nodes.retained_mode.events.mcp_events import (
+    CreateMCPServerRequest,
+    CreateMCPServerResultFailure,
+    CreateMCPServerResultSuccess,
+    DeleteMCPServerRequest,
+    DeleteMCPServerResultFailure,
+    DeleteMCPServerResultSuccess,
+    DisableMCPServerRequest,
+    DisableMCPServerResultFailure,
+    DisableMCPServerResultSuccess,
+    EnableMCPServerRequest,
+    EnableMCPServerResultFailure,
+    EnableMCPServerResultSuccess,
+    GetEnabledMCPServersRequest,
+    GetEnabledMCPServersResultFailure,
+    GetEnabledMCPServersResultSuccess,
+    GetMCPServerRequest,
+    GetMCPServerResultFailure,
+    GetMCPServerResultSuccess,
+    ListMCPServersRequest,
+    ListMCPServersResultFailure,
+    ListMCPServersResultSuccess,
+    UpdateMCPServerRequest,
+    UpdateMCPServerResultFailure,
+    UpdateMCPServerResultSuccess,
+)
+from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
+from griptape_nodes.retained_mode.managers.event_manager import EventManager
+from griptape_nodes.retained_mode.managers.settings import MCPServerConfig
+
+logger = logging.getLogger("griptape_nodes")
+
+
+class MCPManager:
+    """Manager for MCP server configurations and operations."""
+
+    def __init__(self, event_manager: EventManager | None = None, config_manager: ConfigManager | None = None) -> None:
+        """Initialize the MCPManager.
+
+        Args:
+            event_manager: The EventManager instance to use for event handling.
+            config_manager: The ConfigManager instance to use for configuration management.
+        """
+        self.config_manager = config_manager
+        if event_manager is not None:
+            # Register event handlers
+            event_manager.assign_manager_to_request_type(ListMCPServersRequest, self.on_list_mcp_servers_request)
+            event_manager.assign_manager_to_request_type(GetMCPServerRequest, self.on_get_mcp_server_request)
+            event_manager.assign_manager_to_request_type(CreateMCPServerRequest, self.on_create_mcp_server_request)
+            event_manager.assign_manager_to_request_type(UpdateMCPServerRequest, self.on_update_mcp_server_request)
+            event_manager.assign_manager_to_request_type(DeleteMCPServerRequest, self.on_delete_mcp_server_request)
+            event_manager.assign_manager_to_request_type(EnableMCPServerRequest, self.on_enable_mcp_server_request)
+            event_manager.assign_manager_to_request_type(DisableMCPServerRequest, self.on_disable_mcp_server_request)
+            event_manager.assign_manager_to_request_type(
+                GetEnabledMCPServersRequest, self.on_get_enabled_mcp_servers_request
+            )
+
+    def _get_mcp_servers(self, filter_by: dict[str, Any] | None = None) -> list[MCPServerConfig]:
+        """Get the current MCP servers configuration from the config manager.
+
+        Args:
+            filter_by: Optional dict of field=value pairs to filter by.
+                      Keys should match server config field names, values are the expected values.
+        """
+        if self.config_manager is None:
+            return []
+
+        mcp_config_data = self.config_manager.get_config_value("mcp_servers", default=[])
+        if not mcp_config_data:
+            return []
+
+        try:
+            servers = [MCPServerConfig.model_validate(server) for server in mcp_config_data]
+            if filter_by:
+                filtered_servers = []
+                for server in servers:
+                    match = True
+                    for field, value in filter_by.items():
+                        if getattr(server, field, None) != value:
+                            match = False
+                            break
+                    if match:
+                        filtered_servers.append(server)
+                return filtered_servers
+            return servers  # noqa: TRY300
+        except Exception as e:
+            logger.error("Failed to parse MCP servers configuration: %s", e)
+            return []
+
+    def _save_mcp_servers(self, servers: list[MCPServerConfig]) -> None:
+        """Save the MCP servers configuration to the config manager."""
+        if self.config_manager is None:
+            logger.warning("No config manager available, cannot save MCP configuration")
+            return
+
+        try:
+            self.config_manager.set_config_value("mcp_servers", [server.model_dump() for server in servers])
+        except Exception as e:
+            logger.error("Failed to save MCP servers configuration: %s", e)
+
+    def _update_server_fields(self, server_config: MCPServerConfig, request: UpdateMCPServerRequest) -> None:
+        """Update server configuration fields from request."""
+        # Map request fields to server config attributes
+        field_mapping = {
+            "new_name": "name",
+            "transport": "transport",
+            "enabled": "enabled",
+            "command": "command",
+            "args": "args",
+            "env": "env",
+            "cwd": "cwd",
+            "encoding": "encoding",
+            "encoding_error_handler": "encoding_error_handler",
+            "url": "url",
+            "headers": "headers",
+            "timeout": "timeout",
+            "sse_read_timeout": "sse_read_timeout",
+            "terminate_on_close": "terminate_on_close",
+            "description": "description",
+            "capabilities": "capabilities",
+        }
+
+        # Update fields that are not None
+        for request_field, config_field in field_mapping.items():
+            value = getattr(request, request_field, None)
+            if value is not None:
+                setattr(server_config, config_field, value)
+
+    def on_list_mcp_servers_request(
+        self, request: ListMCPServersRequest
+    ) -> ListMCPServersResultSuccess | ListMCPServersResultFailure:
+        """Handle list MCP servers request."""
+        try:
+            servers = self._get_mcp_servers()
+        except Exception as e:
+            logger.error("Failed to list MCP servers: %s", e)
+            return ListMCPServersResultFailure(result_details=f"Failed to list MCP servers: {e}")
+
+        if request.include_disabled:
+            servers_dict = {server.name: server.model_dump() for server in servers}
+        else:
+            enabled_servers = [server for server in servers if server.enabled]
+            servers_dict = {server.name: server.model_dump() for server in enabled_servers}
+
+        # Success path after exception handling
+        return ListMCPServersResultSuccess(
+            # Pydantic model.model_dump() returns dict[str, Any] which matches MCPServerConfig TypedDict structure
+            servers=servers_dict,  # type: ignore[arg-type]
+            result_details=f"Successfully listed {len(servers_dict)} MCP servers",
+        )
+
+    def on_get_mcp_server_request(
+        self, request: GetMCPServerRequest
+    ) -> GetMCPServerResultSuccess | GetMCPServerResultFailure:
+        """Handle get MCP server request."""
+        servers = self._get_mcp_servers(filter_by={"name": request.name})
+        server_config = servers[0] if servers else None
+
+        if server_config is None:
+            return GetMCPServerResultFailure(result_details=f"Failed to get MCP server '{request.name}' - not found")
+
+        # Success path after exception handling
+        return GetMCPServerResultSuccess(
+            # Pydantic model.model_dump() returns dict[str, Any] which matches MCPServerConfig TypedDict structure
+            server_config=server_config.model_dump(),  # type: ignore[arg-type]
+            result_details=f"Successfully retrieved MCP server '{request.name}'",
+        )
+
+    def on_create_mcp_server_request(
+        self, request: CreateMCPServerRequest
+    ) -> CreateMCPServerResultSuccess | CreateMCPServerResultFailure:
+        """Handle create MCP server request."""
+        try:
+            servers = self._get_mcp_servers()
+        except Exception as e:
+            logger.error("Failed to create MCP server '%s': %s", request.name, e)
+            return CreateMCPServerResultFailure(result_details=f"Failed to create MCP server '{request.name}': {e}")
+
+        # Check if server already exists
+        for server in servers:
+            if server.name == request.name:
+                return CreateMCPServerResultFailure(
+                    result_details=f"Failed to create MCP server '{request.name}' - already exists"
+                )
+
+        # Create new server configuration
+        server_config = MCPServerConfig(
+            name=request.name,
+            enabled=request.enabled,
+            transport=request.transport,
+            # StdioConnection fields
+            command=request.command,
+            args=request.args or [],
+            env=request.env or {},
+            cwd=request.cwd,
+            encoding=request.encoding,
+            encoding_error_handler=request.encoding_error_handler,
+            # HTTP-based connection fields
+            url=request.url,
+            headers=request.headers,
+            timeout=request.timeout,
+            sse_read_timeout=request.sse_read_timeout,
+            terminate_on_close=request.terminate_on_close,
+            # Common fields
+            description=request.description,
+            capabilities=request.capabilities or [],
+        )
+
+        servers.append(server_config)
+
+        try:
+            self._save_mcp_servers(servers)
+        except Exception as e:
+            logger.error("Failed to save MCP server '%s': %s", request.name, e)
+            return CreateMCPServerResultFailure(result_details=f"Failed to save MCP server '{request.name}': {e}")
+
+        # Success path after exception handling
+        return CreateMCPServerResultSuccess(
+            name=request.name, result_details=f"Successfully created MCP server '{request.name}'"
+        )
+
+    def on_update_mcp_server_request(
+        self, request: UpdateMCPServerRequest
+    ) -> UpdateMCPServerResultSuccess | UpdateMCPServerResultFailure:
+        """Handle update MCP server request."""
+        servers = self._get_mcp_servers(filter_by={"name": request.name})
+        server_config = servers[0] if servers else None
+
+        if server_config is None:
+            return UpdateMCPServerResultFailure(
+                result_details=f"Failed to update MCP server '{request.name}' - not found"
+            )
+
+        # Update only provided fields
+        self._update_server_fields(server_config, request)
+
+        try:
+            self._save_mcp_servers(servers)
+        except Exception as e:
+            logger.error("Failed to save MCP server '%s': %s", request.name, e)
+            return UpdateMCPServerResultFailure(result_details=f"Failed to save MCP server '{request.name}': {e}")
+
+        # Success path after exception handling
+        return UpdateMCPServerResultSuccess(
+            name=request.name, result_details=f"Successfully updated MCP server '{request.name}'"
+        )
+
+    def on_delete_mcp_server_request(
+        self, request: DeleteMCPServerRequest
+    ) -> DeleteMCPServerResultSuccess | DeleteMCPServerResultFailure:
+        """Handle delete MCP server request."""
+        try:
+            servers = self._get_mcp_servers()
+
+            # Find and remove server by server_id
+            server_found = False
+            for i, server in enumerate(servers):
+                if server.name == request.name:
+                    servers.pop(i)
+                    server_found = True
+                    break
+
+            self._save_mcp_servers(servers)
+
+        except Exception as e:
+            logger.error("Failed to delete MCP server '%s': %s", request.name, e)
+            return DeleteMCPServerResultFailure(result_details=f"Failed to delete MCP server '{request.name}': {e}")
+
+        if not server_found:
+            return DeleteMCPServerResultFailure(
+                result_details=f"Failed to delete MCP server '{request.name}' - not found"
+            )
+
+        # Success path after exception handling
+        return DeleteMCPServerResultSuccess(
+            name=request.name, result_details=f"Successfully deleted MCP server '{request.name}'"
+        )
+
+    def on_enable_mcp_server_request(
+        self, request: EnableMCPServerRequest
+    ) -> EnableMCPServerResultSuccess | EnableMCPServerResultFailure:
+        """Handle enable MCP server request."""
+        servers = self._get_mcp_servers()
+        server_config = None
+        for server in servers:
+            if server.name == request.name:
+                server_config = server
+                break
+
+        if server_config is None:
+            return EnableMCPServerResultFailure(
+                result_details=f"Failed to enable MCP server '{request.name}' - not found"
+            )
+
+        server_config.enabled = True
+
+        try:
+            self._save_mcp_servers(servers)
+        except Exception as e:
+            logger.error("Failed to save MCP server '%s': %s", request.name, e)
+            return EnableMCPServerResultFailure(result_details=f"Failed to save MCP server '{request.name}': {e}")
+
+        # Success path after exception handling
+        return EnableMCPServerResultSuccess(
+            name=request.name, result_details=f"Successfully enabled MCP server '{request.name}'"
+        )
+
+    def on_disable_mcp_server_request(
+        self, request: DisableMCPServerRequest
+    ) -> DisableMCPServerResultSuccess | DisableMCPServerResultFailure:
+        """Handle disable MCP server request."""
+        servers = self._get_mcp_servers()
+        server_config = None
+        for server in servers:
+            if server.name == request.name:
+                server_config = server
+                break
+
+        if server_config is None:
+            return DisableMCPServerResultFailure(
+                result_details=f"Failed to disable MCP server '{request.name}' - not found"
+            )
+
+        server_config.enabled = False
+
+        try:
+            self._save_mcp_servers(servers)
+        except Exception as e:
+            logger.error("Failed to save MCP server '%s': %s", request.name, e)
+            return DisableMCPServerResultFailure(result_details=f"Failed to save MCP server '{request.name}': {e}")
+
+        # Success path after exception handling
+        return DisableMCPServerResultSuccess(
+            name=request.name, result_details=f"Successfully disabled MCP server '{request.name}'"
+        )
+
+    def on_get_enabled_mcp_servers_request(
+        self,
+        request: GetEnabledMCPServersRequest,  # noqa: ARG002
+    ) -> GetEnabledMCPServersResultSuccess | GetEnabledMCPServersResultFailure:
+        """Handle get enabled MCP servers request."""
+        try:
+            enabled_servers = self._get_mcp_servers(filter_by={"enabled": True})
+            servers_dict = {server.name: server.model_dump() for server in enabled_servers}
+
+        except Exception as e:
+            logger.error("Failed to get enabled MCP servers: %s", e)
+            return GetEnabledMCPServersResultFailure(result_details=f"Failed to get enabled MCP servers: {e}")
+
+        # Success path after exception handling
+        return GetEnabledMCPServersResultSuccess(
+            # Pydantic model.model_dump() returns dict[str, Any] which matches MCPServerConfig TypedDict structure
+            servers=servers_dict,  # type: ignore[arg-type]
+            result_details=f"Successfully retrieved {len(servers_dict)} enabled MCP servers",
+        )