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

griptape_nodes/retained_mode/events/workflow_events.py

@@ -1,7 +1,8 @@
 from dataclasses import dataclass
-from typing import Literal
+from datetime import datetime
+from typing import TYPE_CHECKING, Literal
 
-from griptape_nodes.node_library.workflow_registry import WorkflowMetadata
+from griptape_nodes.node_library.workflow_registry import WorkflowMetadata, WorkflowShape
 from griptape_nodes.retained_mode.events.base_events import (
     RequestPayload,
     ResultPayloadFailure,
@@ -11,6 +12,9 @@ from griptape_nodes.retained_mode.events.base_events import (
 )
 from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
 
+if TYPE_CHECKING:
+    from griptape_nodes.retained_mode.events.flow_events import SerializedFlowCommands
+
 
 @dataclass
 @PayloadRegistry.register
@@ -632,3 +636,54 @@ class RegisterWorkflowsFromConfigResultSuccess(WorkflowNotAlteredMixin, ResultPa
 @PayloadRegistry.register
 class RegisterWorkflowsFromConfigResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
     """Workflow registration from configuration failed. Common causes: configuration not found, invalid paths, registration errors."""
+
+
+@dataclass
+@PayloadRegistry.register
+class SaveWorkflowFileFromSerializedFlowRequest(RequestPayload):
+    """Save a workflow file from serialized flow commands without registry overhead.
+
+    Use when: Creating workflow files from user-supplied subsets of existing workflows,
+    exporting partial workflows, creating standalone workflow files without registration.
+
+    Args:
+        serialized_flow_commands: The serialized commands representing the workflow structure
+        file_name: Name for the workflow file (without .py extension)
+        creation_date: Optional creation date for the workflow metadata (defaults to current time if not provided)
+        image_path: Optional path to workflow image/thumbnail
+        execution_flow_name: Optional flow name to use for execution code (defaults to file_name if not provided)
+        branched_from: Optional branched from information to preserve workflow lineage
+        workflow_shape: Optional workflow shape defining inputs and outputs for external callers
+        file_path: Optional specific file path to use (defaults to workspace path if not provided)
+
+    Results: SaveWorkflowFileFromSerializedFlowResultSuccess (with file path) | SaveWorkflowFileFromSerializedFlowResultFailure (save error)
+    """
+
+    serialized_flow_commands: "SerializedFlowCommands"
+    file_name: str
+    file_path: str | None = None
+    creation_date: datetime | None = None
+    image_path: str | None = None
+    execution_flow_name: str | None = None
+    branched_from: str | None = None
+    workflow_shape: WorkflowShape | None = None
+
+
+@dataclass
+@PayloadRegistry.register
+class SaveWorkflowFileFromSerializedFlowResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Workflow file saved successfully from serialized flow commands.
+
+    Args:
+        file_path: Path where the workflow file was written
+        workflow_metadata: The metadata that was generated for the workflow
+    """
+
+    file_path: str
+    workflow_metadata: WorkflowMetadata
+
+
+@dataclass
+@PayloadRegistry.register
+class SaveWorkflowFileFromSerializedFlowResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Workflow file save failed. Common causes: file system error, permission denied, invalid serialized commands."""

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
@@ -69,6 +70,7 @@ if TYPE_CHECKING:
         OperationDepthManager,
     )
     from griptape_nodes.retained_mode.managers.os_manager import OSManager
+    from griptape_nodes.retained_mode.managers.resource_manager import ResourceManager
     from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
     from griptape_nodes.retained_mode.managers.session_manager import SessionManager
     from griptape_nodes.retained_mode.managers.static_files_manager import (
@@ -149,9 +151,11 @@ class GriptapeNodes(metaclass=SingletonMeta):
     _version_compatibility_manager: VersionCompatibilityManager
     _session_manager: SessionManager
     _engine_identity_manager: EngineIdentityManager
+    _mcp_manager: MCPManager
+    _resource_manager: ResourceManager
     _sync_manager: SyncManager
 
-    def __init__(self) -> None:
+    def __init__(self) -> None:  # noqa: PLR0915
         from griptape_nodes.retained_mode.managers.agent_manager import AgentManager
         from griptape_nodes.retained_mode.managers.arbitrary_code_exec_manager import (
             ArbitraryCodeExecManager,
@@ -162,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
@@ -169,6 +174,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
             OperationDepthManager,
         )
         from griptape_nodes.retained_mode.managers.os_manager import OSManager
+        from griptape_nodes.retained_mode.managers.resource_manager import ResourceManager
         from griptape_nodes.retained_mode.managers.secrets_manager import SecretsManager
         from griptape_nodes.retained_mode.managers.session_manager import SessionManager
         from griptape_nodes.retained_mode.managers.static_files_manager import (
@@ -188,6 +194,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
         # Initialize only if our managers haven't been created yet
         if not hasattr(self, "_event_manager"):
             self._event_manager = EventManager()
+            self._resource_manager = ResourceManager(self._event_manager)
             self._config_manager = ConfigManager(self._event_manager)
             self._os_manager = OSManager(self._event_manager)
             self._secrets_manager = SecretsManager(self._config_manager, self._event_manager)
@@ -208,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.
@@ -370,10 +378,18 @@ 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
 
+    @classmethod
+    def ResourceManager(cls) -> ResourceManager:
+        return GriptapeNodes.get_instance()._resource_manager
+
     @classmethod
     def SyncManager(cls) -> SyncManager:
         return GriptapeNodes.get_instance()._sync_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],