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

griptape_nodes/retained_mode/events/mcp_events.py

@@ -0,0 +1,363 @@
+"""MCP (Model Context Protocol) server management events."""
+
+from dataclasses import dataclass
+from typing import Any, TypedDict
+
+from griptape_nodes.retained_mode.events.base_events import (
+    RequestPayload,
+    ResultPayloadFailure,
+    ResultPayloadSuccess,
+    WorkflowAlteredMixin,
+    WorkflowNotAlteredMixin,
+)
+from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
+
+
+# Type definitions for better clarity
+class MCPServerConfig(TypedDict, total=False):
+    """Configuration for an MCP server."""
+
+    name: str
+    transport: str  # Transport protocol type
+    enabled: bool
+    command: str | None  # Process command for stdio transport
+    args: list[str] | None  # Process arguments for stdio transport
+    env: dict[str, str] | None  # Environment variables for stdio transport
+    cwd: str | None  # Working directory for stdio transport
+    encoding: str  # Text encoding for stdio transport
+    encoding_error_handler: str  # Error handling strategy for stdio transport
+    url: str | None  # Connection URL for HTTP-based transports
+    headers: dict[str, str] | None  # HTTP headers for HTTP-based transports
+    timeout: float | None  # Connection timeout for HTTP-based transports
+    sse_read_timeout: float | None  # Read timeout for SSE transport
+    terminate_on_close: bool  # Session termination behavior for streamable HTTP transport
+    description: str | None
+    capabilities: list[str] | None
+
+
+class MCPServerCapability(TypedDict):
+    """Information about an MCP server capability."""
+
+    name: str
+    description: str | None
+    input_schema: dict[str, Any] | None  # JSON schema for capability inputs
+    output_schema: dict[str, Any] | None  # JSON schema for capability outputs
+
+
+class MCPServerInfo(TypedDict, total=False):
+    """Information about an MCP server."""
+
+    name: str
+    version: str | None  # Server version identifier
+    description: str | None  # Human-readable server description
+    capabilities: list[str] | None  # List of supported capability names
+
+
+# MCP Server Management Events
+
+
+# Capability Discovery Events
+@dataclass
+@PayloadRegistry.register
+class DiscoverMCPServerCapabilitiesRequest(RequestPayload):
+    """Discover capabilities from a running MCP server.
+
+    Args:
+        name: The MCP server identifier to discover capabilities from
+        timeout: Maximum time to wait for server response in seconds
+    """
+
+    name: str
+    timeout: int = 30
+
+
+@dataclass
+@PayloadRegistry.register
+class DiscoverMCPServerCapabilitiesResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """MCP server capabilities discovered successfully."""
+
+    name: str
+    capabilities: list[str]
+    detailed_tools: list[MCPServerCapability] | None = None
+    server_info: MCPServerInfo | None = None
+
+
+@dataclass
+@PayloadRegistry.register
+class DiscoverMCPServerCapabilitiesResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Failed to discover MCP server capabilities."""
+
+
+@dataclass
+@PayloadRegistry.register
+class ListMCPServersRequest(RequestPayload):
+    """List all configured MCP servers.
+
+    Args:
+        include_disabled: Whether to include disabled servers in the results
+    """
+
+    include_disabled: bool = False
+
+
+@dataclass
+@PayloadRegistry.register
+class ListMCPServersResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """MCP servers listed successfully."""
+
+    servers: dict[str, MCPServerConfig]
+
+
+@dataclass
+@PayloadRegistry.register
+class ListMCPServersResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Failed to list MCP servers."""
+
+
+@dataclass
+@PayloadRegistry.register
+class GetMCPServerRequest(RequestPayload):
+    """Get configuration for a specific MCP server.
+
+    Args:
+        name: The unique identifier for the MCP server
+    """
+
+    name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class GetMCPServerResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """MCP server configuration retrieved successfully."""
+
+    server_config: MCPServerConfig
+
+
+@dataclass
+@PayloadRegistry.register
+class GetMCPServerResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Failed to get MCP server configuration."""
+
+
+@dataclass
+@PayloadRegistry.register
+class CreateMCPServerRequest(RequestPayload):
+    """Create a new MCP server configuration.
+
+    Args:
+        name: Unique identifier for the server
+        transport: Transport protocol type
+        command: Process command to start the server (required for stdio transport)
+        args: Process arguments to pass to the command (stdio transport)
+        env: Environment variables for the server process (stdio transport)
+        cwd: Working directory for the server process (stdio transport)
+        encoding: Text encoding for stdio communication
+        encoding_error_handler: Encoding error handling strategy for stdio
+        url: Connection URL for HTTP-based transports
+        headers: HTTP headers for HTTP-based connections
+        timeout: Connection timeout in seconds
+        sse_read_timeout: SSE read timeout in seconds
+        terminate_on_close: Session termination behavior for streamable HTTP transport
+        description: Optional description of the server
+        capabilities: List of server capabilities
+        enabled: Whether the server is enabled by default
+    """
+
+    name: str
+    transport: str = "stdio"
+    enabled: bool = True
+
+    # StdioConnection fields
+    command: str | None = None
+    args: list[str] | None = None
+    env: dict[str, str] | None = None
+    cwd: str | None = None
+    encoding: str = "utf-8"
+    encoding_error_handler: str = "strict"
+
+    # HTTP-based connection fields
+    url: str | None = None
+    headers: dict[str, str] | None = None
+    timeout: float | None = None
+    sse_read_timeout: float | None = None
+    terminate_on_close: bool = True
+
+    # Common fields
+    description: str | None = None
+    capabilities: list[str] | None = None
+
+
+@dataclass
+@PayloadRegistry.register
+class CreateMCPServerResultSuccess(WorkflowAlteredMixin, ResultPayloadSuccess):
+    """MCP server created successfully."""
+
+    name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class CreateMCPServerResultFailure(WorkflowAlteredMixin, ResultPayloadFailure):
+    """Failed to create MCP server."""
+
+
+@dataclass
+@PayloadRegistry.register
+class UpdateMCPServerRequest(RequestPayload):
+    """Update an existing MCP server configuration.
+
+    Args:
+        name: The unique identifier for the MCP server
+        new_name: Updated display name for the server
+        transport: Updated transport protocol type
+        command: Updated process command to start the server (stdio transport)
+        args: Updated process arguments to pass to the command (stdio transport)
+        env: Updated environment variables for the server process (stdio transport)
+        cwd: Updated working directory for the server process (stdio transport)
+        encoding: Updated text encoding for stdio communication
+        encoding_error_handler: Updated encoding error handling strategy for stdio
+        url: Updated connection URL for HTTP-based transports
+        headers: Updated HTTP headers for HTTP-based connections
+        timeout: Updated connection timeout in seconds
+        sse_read_timeout: Updated SSE read timeout in seconds
+        terminate_on_close: Updated session termination behavior for streamable HTTP transport
+        description: Updated description of the server
+        capabilities: Updated list of server capabilities
+    """
+
+    name: str
+    new_name: str | None = None
+    transport: str | None = None
+    enabled: bool | None = None
+
+    # StdioConnection fields
+    command: str | None = None
+    args: list[str] | None = None
+    env: dict[str, str] | None = None
+    cwd: str | None = None
+    encoding: str | None = None
+    encoding_error_handler: str | None = None
+
+    # HTTP-based connection fields
+    url: str | None = None
+    headers: dict[str, str] | None = None
+    timeout: float | None = None
+    sse_read_timeout: float | None = None
+    terminate_on_close: bool | None = None
+
+    # Common fields
+    description: str | None = None
+    capabilities: list[str] | None = None
+
+
+@dataclass
+@PayloadRegistry.register
+class UpdateMCPServerResultSuccess(WorkflowAlteredMixin, ResultPayloadSuccess):
+    """MCP server updated successfully."""
+
+    name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class UpdateMCPServerResultFailure(WorkflowAlteredMixin, ResultPayloadFailure):
+    """Failed to update MCP server."""
+
+
+@dataclass
+@PayloadRegistry.register
+class DeleteMCPServerRequest(RequestPayload):
+    """Delete an MCP server configuration.
+
+    Args:
+        name: The unique identifier for the MCP server to delete
+    """
+
+    name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class DeleteMCPServerResultSuccess(WorkflowAlteredMixin, ResultPayloadSuccess):
+    """MCP server deleted successfully."""
+
+    name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class DeleteMCPServerResultFailure(WorkflowAlteredMixin, ResultPayloadFailure):
+    """Failed to delete MCP server."""
+
+
+@dataclass
+@PayloadRegistry.register
+class EnableMCPServerRequest(RequestPayload):
+    """Enable an MCP server.
+
+    Args:
+        name: The unique identifier for the MCP server to enable
+    """
+
+    name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class EnableMCPServerResultSuccess(WorkflowAlteredMixin, ResultPayloadSuccess):
+    """MCP server enabled successfully."""
+
+    name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class EnableMCPServerResultFailure(WorkflowAlteredMixin, ResultPayloadFailure):
+    """Failed to enable MCP server."""
+
+
+@dataclass
+@PayloadRegistry.register
+class DisableMCPServerRequest(RequestPayload):
+    """Disable an MCP server.
+
+    Args:
+        name: The unique identifier for the MCP server to disable
+    """
+
+    name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class DisableMCPServerResultSuccess(WorkflowAlteredMixin, ResultPayloadSuccess):
+    """MCP server disabled successfully."""
+
+    name: str
+
+
+@dataclass
+@PayloadRegistry.register
+class DisableMCPServerResultFailure(WorkflowAlteredMixin, ResultPayloadFailure):
+    """Failed to disable MCP server."""
+
+
+@dataclass
+@PayloadRegistry.register
+class GetEnabledMCPServersRequest(RequestPayload):
+    """Get all enabled MCP servers."""
+
+
+@dataclass
+@PayloadRegistry.register
+class GetEnabledMCPServersResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Enabled MCP servers retrieved successfully."""
+
+    servers: dict[str, MCPServerConfig]
+
+
+@dataclass
+@PayloadRegistry.register
+class GetEnabledMCPServersResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Failed to get enabled MCP servers."""

griptape_nodes/retained_mode/events/node_events.py

@@ -4,8 +4,7 @@ from typing import Any, NamedTuple, NewType
 from uuid import uuid4
 
 from griptape_nodes.exe_types.core_types import NodeMessagePayload
-from griptape_nodes.exe_types.node_types import NodeResolutionState
-from griptape_nodes.node_library.library_registry import LibraryNameAndVersion
+from griptape_nodes.exe_types.node_types import NodeDependencies, NodeResolutionState
 from griptape_nodes.retained_mode.events.base_events import (
     RequestPayload,
     ResultPayloadFailure,
@@ -409,7 +408,7 @@ class SerializedNodeCommands:
     Attributes:
         create_node_command (CreateNodeRequest): The command to create the node.
         element_modification_commands (list[RequestPayload]): A list of commands to create or modify the elements (including Parameters) of the node.
-        node_library_details (LibraryNameAndVersion): Details of the library and version used by the node.
+        node_dependencies (NodeDependencies): Dependencies that this node has on external resources (workflows, files, imports, libraries).
         node_uuid (NodeUUID): The UUID of this particular node. During deserialization, this UUID will be used to correlate this node's instance
             with the connections and parameter values necessary. We cannot use node name because Griptape Nodes enforces unique names, and we cannot
             predict the name that will be selected upon instantiation. Similarly, the same serialized node may be deserialized multiple times, such
@@ -435,7 +434,7 @@ class SerializedNodeCommands:
 
     create_node_command: CreateNodeRequest
     element_modification_commands: list[RequestPayload]
-    node_library_details: LibraryNameAndVersion
+    node_dependencies: NodeDependencies
     lock_node_command: SetLockNodeStateRequest | None = None
     node_uuid: NodeUUID = field(default_factory=lambda: SerializedNodeCommands.NodeUUID(str(uuid4())))
 

griptape_nodes/retained_mode/griptape_nodes.py

@@ -62,6 +62,7 @@ if TYPE_CHECKING:
     from griptape_nodes.retained_mode.managers.event_manager import EventManager
     from griptape_nodes.retained_mode.managers.flow_manager import FlowManager
     from griptape_nodes.retained_mode.managers.library_manager import LibraryManager
+    from griptape_nodes.retained_mode.managers.mcp_manager import MCPManager
     from griptape_nodes.retained_mode.managers.model_manager import ModelManager
     from griptape_nodes.retained_mode.managers.node_manager import NodeManager
     from griptape_nodes.retained_mode.managers.object_manager import ObjectManager
@@ -150,6 +151,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
     _version_compatibility_manager: VersionCompatibilityManager
     _session_manager: SessionManager
     _engine_identity_manager: EngineIdentityManager
+    _mcp_manager: MCPManager
     _resource_manager: ResourceManager
     _sync_manager: SyncManager
 
@@ -164,6 +166,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
         from griptape_nodes.retained_mode.managers.event_manager import EventManager
         from griptape_nodes.retained_mode.managers.flow_manager import FlowManager
         from griptape_nodes.retained_mode.managers.library_manager import LibraryManager
+        from griptape_nodes.retained_mode.managers.mcp_manager import MCPManager
         from griptape_nodes.retained_mode.managers.model_manager import ModelManager
         from griptape_nodes.retained_mode.managers.node_manager import NodeManager
         from griptape_nodes.retained_mode.managers.object_manager import ObjectManager
@@ -212,6 +215,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
             self._version_compatibility_manager = VersionCompatibilityManager(self._event_manager)
             self._session_manager = SessionManager(self._event_manager)
             self._engine_identity_manager = EngineIdentityManager(self._event_manager)
+            self._mcp_manager = MCPManager(self._event_manager, self._config_manager)
             self._sync_manager = SyncManager(self._event_manager, self._config_manager)
 
             # Assign handlers now that these are created.
@@ -374,6 +378,10 @@ class GriptapeNodes(metaclass=SingletonMeta):
     def SessionManager(cls) -> SessionManager:
         return GriptapeNodes.get_instance()._session_manager
 
+    @classmethod
+    def MCPManager(cls) -> MCPManager:
+        return GriptapeNodes.get_instance()._mcp_manager
+
     @classmethod
     def EngineIdentityManager(cls) -> EngineIdentityManager:
         return GriptapeNodes.get_instance()._engine_identity_manager

griptape_nodes/retained_mode/managers/agent_manager.py

@@ -4,7 +4,7 @@ import logging
 import os
 import threading
 import uuid
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, ClassVar
 
 from attrs import define, field
 from griptape.artifacts import ErrorArtifact, ImageUrlArtifact, JsonArtifact
@@ -40,6 +40,10 @@ from griptape_nodes.retained_mode.events.agent_events import (
 )
 from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
 from griptape_nodes.retained_mode.events.base_events import ExecutionEvent, ExecutionGriptapeNodeEvent, ResultPayload
+from griptape_nodes.retained_mode.events.mcp_events import (
+    GetEnabledMCPServersRequest,
+    GetEnabledMCPServersResultSuccess,
+)
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes
 from griptape_nodes.retained_mode.managers.config_manager import ConfigManager
 from griptape_nodes.retained_mode.managers.event_manager import EventManager
@@ -91,6 +95,14 @@ class NodesPromptImageGenerationTool(BaseImageGenerationTool):
 
 
 class AgentManager:
+    # Field mappings for each transport type
+    TRANSPORT_FIELD_MAPPINGS: ClassVar[dict[str, list[str]]] = {
+        "stdio": ["command", "args", "env", "cwd", "encoding", "encoding_error_handler"],
+        "sse": ["url", "headers", "timeout", "sse_read_timeout"],
+        "streamable_http": ["url", "headers", "timeout", "sse_read_timeout", "terminate_on_close"],
+        "websocket": ["url"],
+    }
+
     def __init__(self, static_files_manager: StaticFilesManager, event_manager: EventManager | None = None) -> None:
         self.conversation_memory = ConversationMemory()
         self.prompt_driver = None
@@ -135,7 +147,53 @@ class AgentManager:
             "transport": "streamable_http",
             "url": f"http://localhost:{GTN_MCP_SERVER_PORT}/mcp/",
         }
-        return MCPTool(connection=connection)
+        return MCPTool(connection=connection, name="mcpGriptapeNodes")
+
+    def _create_additional_mcp_tools(self, server_names: list[str]) -> list[MCPTool]:
+        """Create MCP tools for additional servers specified in the request."""
+        additional_tools = []
+
+        try:
+            app = GriptapeNodes()
+
+            enabled_request = GetEnabledMCPServersRequest()
+            enabled_result = app.handle_request(enabled_request)
+
+            if not isinstance(enabled_result, GetEnabledMCPServersResultSuccess):
+                msg = f"Failed to get enabled MCP servers for additional tools: {enabled_result}. Agent will continue with default MCP tool only."
+                logger.warning(msg)
+                return additional_tools
+
+            for server_name in server_names:
+                if server_name in enabled_result.servers:
+                    server_config = enabled_result.servers[server_name]
+                    connection = self._create_connection_from_mcp_config(server_config)  # type: ignore[arg-type]
+                    tool = MCPTool(connection=connection, name=f"mcp{server_name.title()}")  # type: ignore[arg-type]
+                    additional_tools.append(tool)
+                else:
+                    msg = f"Additional MCP server '{server_name}' not found or not enabled"
+                    logger.warning(msg)
+
+        except Exception as e:
+            msg = f"Failed to create additional MCP tools: {e}"
+            logger.error(msg)
+
+        return additional_tools
+
+    def _create_connection_from_mcp_config(self, server_config: dict) -> dict:
+        """Create connection dictionary from MCP server configuration."""
+        transport = server_config.get("transport", "stdio")
+
+        # Start with transport
+        connection = {"transport": transport}
+
+        # Map relevant fields based on transport type
+        fields_to_map = self.TRANSPORT_FIELD_MAPPINGS.get(transport, self.TRANSPORT_FIELD_MAPPINGS["stdio"])
+        for field_name in fields_to_map:
+            if field_name in server_config and server_config[field_name] is not None:
+                connection[field_name] = server_config[field_name]
+
+        return connection
 
     async def on_handle_run_agent_request(self, request: RunAgentRequest) -> ResultPayload:
         if self.prompt_driver is None:
@@ -147,7 +205,7 @@ class AgentManager:
         await asyncio.to_thread(self._on_handle_run_agent_request, request)
         return RunAgentResultStarted(result_details="Agent execution started successfully.")
 
-    def _create_agent(self) -> Agent:
+    def _create_agent(self, additional_mcp_servers: list[str] | None = None) -> Agent:
         output_schema = Schema(
             {
                 "generated_image_urls": [str],
@@ -161,6 +219,11 @@ class AgentManager:
         if self.mcp_tool is not None:
             tools.append(self.mcp_tool)
 
+        # Add additional MCP servers if specified
+        if additional_mcp_servers:
+            additional_tools = self._create_additional_mcp_tools(additional_mcp_servers)
+            tools.extend(additional_tools)
+
         return Agent(
             prompt_driver=self.prompt_driver,
             conversation_memory=self.conversation_memory,
@@ -185,7 +248,7 @@ class AgentManager:
                 for url_artifact in request.url_artifacts
                 if url_artifact["type"] == "ImageUrlArtifact"
             ]
-            agent = self._create_agent()
+            agent = self._create_agent(additional_mcp_servers=request.additional_mcp_servers)
             *events, last_event = agent.run_stream([request.input, *artifacts])
             full_result = ""
             last_conversation_output = ""

griptape_nodes/retained_mode/managers/event_manager.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import inspect
+import threading
 from collections import defaultdict
 from dataclasses import fields
 from typing import TYPE_CHECKING, Any, cast
@@ -43,6 +44,10 @@ class EventManager:
         self._flush_in_queue: bool = False
         # Event queue for publishing events
         self._event_queue: asyncio.Queue | None = None
+        # Keep track of which thread the event loop runs on
+        self._loop_thread_id: int | None = None
+        # Keep a reference to the event loop for thread-safe operations
+        self._event_loop: asyncio.AbstractEventLoop | None = None
 
     @property
     def event_queue(self) -> asyncio.Queue:
@@ -62,23 +67,48 @@ class EventManager:
         """
         if queue is not None:
             self._event_queue = queue
+            # Track which thread the event loop is running on and store loop reference
+            try:
+                self._event_loop = asyncio.get_running_loop()
+                self._loop_thread_id = threading.get_ident()
+            except RuntimeError:
+                self._event_loop = None
+                self._loop_thread_id = None
         else:
             try:
                 self._event_queue = asyncio.Queue()
+                self._event_loop = asyncio.get_running_loop()
+                self._loop_thread_id = threading.get_ident()
             except RuntimeError:
                 # Defer queue creation until we're in an event loop
                 self._event_queue = None
+                self._event_loop = None
+                self._loop_thread_id = None
 
     def put_event(self, event: Any) -> None:
         """Put event into async queue from sync context (non-blocking).
 
+        Automatically detects if we're in a different thread and uses thread-safe operations.
+
         Args:
             event: The event to publish to the queue
         """
         if self._event_queue is None:
             return
 
-        self._event_queue.put_nowait(event)
+        # Check if we need thread-safe operation
+        current_thread_id = threading.get_ident()
+
+        if (
+            self._loop_thread_id is not None
+            and current_thread_id != self._loop_thread_id
+            and self._event_loop is not None
+        ):
+            # We're in a different thread from the event loop, use thread-safe method
+            self._event_loop.call_soon_threadsafe(self._event_queue.put_nowait, event)
+        else:
+            # We're on the same thread as the event loop or no loop thread tracked, use direct method
+            self._event_queue.put_nowait(event)
 
     async def aput_event(self, event: Any) -> None:
         """Put event into async queue from async context.
@@ -91,18 +121,6 @@ class EventManager:
 
         await self._event_queue.put(event)
 
-    def put_event_threadsafe(self, loop: Any, event: Any) -> None:
-        """Put event into async queue from sync context in a thread-safe manner.
-
-        Args:
-            loop: The asyncio event loop to use for thread-safe operation
-            event: The event to publish to the queue
-        """
-        if self._event_queue is None:
-            return
-
-        loop.call_soon_threadsafe(self._event_queue.put_nowait, event)
-
     def assign_manager_to_request_type(
         self,
         request_type: type[RP],