griptape-nodes 0.42.0__py3-none-any.whl → 0.43.0__py3-none-any.whl

griptape_nodes/retained_mode/events/base_events.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 from abc import ABC, abstractmethod
 from dataclasses import asdict, dataclass, field, is_dataclass
-from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar
+from typing import TYPE_CHECKING, Any, ClassVar, TypeVar
 
 from griptape.artifacts import BaseArtifact
 from griptape.events import BaseEvent as GtBaseEvent
@@ -101,7 +101,7 @@ class AppPayload(Payload):
 
 
 # Type variables for our generic payloads
-P = TypeVar("P", bound=Payload)
+P = TypeVar("P", bound=RequestPayload)
 R = TypeVar("R", bound=ResultPayload)
 E = TypeVar("E", bound=ExecutionPayload)
 A = TypeVar("A", bound=AppPayload)
@@ -181,7 +181,7 @@ class BaseEvent(BaseModel, ABC):
         """
 
 
-class EventRequest(BaseEvent, Generic[P]):
+class EventRequest[P: Payload](BaseEvent):
     """Request event."""
 
     request: P
@@ -245,7 +245,7 @@ class EventRequest(BaseEvent, Generic[P]):
         return cls(request=request_payload, **event_data)
 
 
-class EventResult(BaseEvent, Generic[P, R], ABC):
+class EventResult[P: RequestPayload, R: ResultPayload](BaseEvent, ABC):
     """Abstract base class for result events."""
 
     request: P
@@ -429,7 +429,7 @@ def deserialize_event(json_data: str | dict | Any) -> BaseEvent:
 
 
 # EXECUTION EVENT BASE (this event type is used for the execution of a Griptape Nodes flow)
-class ExecutionEvent(BaseEvent, Generic[E]):
+class ExecutionEvent[E: ExecutionPayload](BaseEvent):
     payload: E
 
     def __init__(self, **data) -> None:
@@ -490,7 +490,7 @@ class ExecutionEvent(BaseEvent, Generic[E]):
 
 
 # Events sent as part of the lifecycle of the Griptape Nodes application.
-class AppEvent(BaseEvent, Generic[A]):
+class AppEvent[A: AppPayload](BaseEvent):
     payload: A
 
     def __init__(self, **data) -> None:

griptape_nodes/retained_mode/events/library_events.py

@@ -14,7 +14,7 @@ from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
 
 if TYPE_CHECKING:
     from griptape_nodes.node_library.library_registry import LibraryMetadata, LibrarySchema, NodeMetadata
-    from griptape_nodes.retained_mode.managers.library_manager import LibraryManager
+    from griptape_nodes.retained_mode.managers.library_lifecycle.library_status import LibraryStatus
 
 
 @dataclass
@@ -207,7 +207,7 @@ class LoadLibraryMetadataFromFileResultFailure(WorkflowNotAlteredMixin, ResultPa
 
     library_path: str
     library_name: str | None
-    status: LibraryManager.LibraryStatus
+    status: LibraryStatus
     problems: list[str]
 
 

griptape_nodes/retained_mode/events/os_events.py

@@ -9,6 +9,17 @@ from griptape_nodes.retained_mode.events.base_events import (
 from griptape_nodes.retained_mode.events.payload_registry import PayloadRegistry
 
 
+@dataclass
+class FileSystemEntry:
+    """Represents a file or directory in the file system."""
+
+    name: str
+    path: str
+    is_dir: bool
+    size: int
+    modified_time: float
+
+
 @dataclass
 @PayloadRegistry.register
 class OpenAssociatedFileRequest(RequestPayload):
@@ -18,12 +29,14 @@ class OpenAssociatedFileRequest(RequestPayload):
     providing file viewing capabilities, implementing file associations.
 
     Args:
-        path_to_file: Path to the file to open with the associated application
+        path_to_file: Path to the file to open (mutually exclusive with file_entry)
+        file_entry: FileSystemEntry object from directory listing (mutually exclusive with path_to_file)
 
     Results: OpenAssociatedFileResultSuccess | OpenAssociatedFileResultFailure (file not found, no association)
     """
 
-    path_to_file: str
+    path_to_file: str | None = None
+    file_entry: FileSystemEntry | None = None
 
 
 @dataclass
@@ -36,3 +49,92 @@ class OpenAssociatedFileResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSucc
 @PayloadRegistry.register
 class OpenAssociatedFileResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
     """File opening failed. Common causes: file not found, no associated application, permission denied."""
+
+
+@dataclass
+@PayloadRegistry.register
+class ListDirectoryRequest(RequestPayload):
+    """List contents of a directory.
+
+    Use when: Browsing file system, showing directory contents,
+    implementing file pickers, navigating folder structures.
+
+    Args:
+        directory_path: Path to the directory to list (None for current directory)
+        show_hidden: Whether to show hidden files/folders
+        workspace_only: If True, constrain to workspace directory. If False, allow system-wide browsing.
+                        If None, workspace constraints don't apply (e.g., cloud environments).
+
+    Results: ListDirectoryResultSuccess (with entries) | ListDirectoryResultFailure (access denied, not found)
+    """
+
+    directory_path: str | None = None
+    show_hidden: bool = False
+    workspace_only: bool | None = True
+
+
+@dataclass
+@PayloadRegistry.register
+class ListDirectoryResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """Directory listing retrieved successfully."""
+
+    entries: list[FileSystemEntry]
+    current_path: str
+    is_workspace_path: bool
+
+
+@dataclass
+@PayloadRegistry.register
+class ListDirectoryResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """Directory listing failed. Common causes: access denied, path not found."""
+
+
+@dataclass
+@PayloadRegistry.register
+class ReadFileRequest(RequestPayload):
+    """Read contents of a file, automatically detecting if it's text or binary using MIME types.
+
+    Use when: Reading file contents for display, processing, or analysis.
+    Automatically detects file type using MIME type detection and returns appropriate content format.
+
+    Args:
+        file_path: Path to the file to read (mutually exclusive with file_entry)
+        file_entry: FileSystemEntry object from directory listing (mutually exclusive with file_path)
+        encoding: Text encoding to use if file is detected as text (default: 'utf-8')
+        workspace_only: If True, constrain to workspace directory. If False, allow system-wide access.
+                        If None, workspace constraints don't apply (e.g., cloud environments).
+
+    Results: ReadFileResultSuccess (with content) | ReadFileResultFailure (file not found, permission denied)
+    """
+
+    file_path: str | None = None
+    file_entry: FileSystemEntry | None = None
+    encoding: str = "utf-8"
+    workspace_only: bool | None = True
+
+
+@dataclass
+@PayloadRegistry.register
+class ReadFileResultSuccess(WorkflowNotAlteredMixin, ResultPayloadSuccess):
+    """File contents read successfully."""
+
+    content: str | bytes  # String for text files, bytes for binary files
+    file_size: int
+    mime_type: str  # e.g., "text/plain", "image/png", "application/pdf"
+    encoding: str | None  # Text encoding used (None for binary files)
+    compression_encoding: str | None = None  # Compression encoding (e.g., "gzip", "bzip2", None)
+    is_text: bool = False  # Will be computed from content type
+
+    def __post_init__(self) -> None:
+        """Compute is_text from content type after initialization."""
+        # For images, even though content is a string (base64), it's not text content
+        if self.mime_type.startswith("image/"):
+            self.is_text = False
+        else:
+            self.is_text = isinstance(self.content, str)
+
+
+@dataclass
+@PayloadRegistry.register
+class ReadFileResultFailure(WorkflowNotAlteredMixin, ResultPayloadFailure):
+    """File reading failed. Common causes: file not found, permission denied, encoding error."""

griptape_nodes/retained_mode/griptape_nodes.py

@@ -9,11 +9,10 @@ from dataclasses import dataclass
 from datetime import UTC, datetime
 from typing import TYPE_CHECKING, Any
 
-import httpx
-
 from griptape_nodes.exe_types.flow import ControlFlow
 from griptape_nodes.node_library.workflow_registry import WorkflowRegistry
 from griptape_nodes.retained_mode.events.app_events import (
+    AppConnectionEstablished,
     AppEndSessionRequest,
     AppEndSessionResultFailure,
     AppEndSessionResultSuccess,
@@ -119,6 +118,10 @@ class Version:
         """Equality comparison."""
         return (self.major, self.minor, self.patch) == (other.major, other.minor, other.patch)
 
+    def __hash__(self) -> int:
+        """Hash function for Version."""
+        return hash((self.major, self.minor, self.patch))
+
 
 class GriptapeNodes(metaclass=SingletonMeta):
     _event_manager: EventManager
@@ -171,8 +174,8 @@ 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._os_manager = OSManager(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)
             self._object_manager = ObjectManager(self._event_manager)
             self._node_manager = NodeManager(self._event_manager)
@@ -198,6 +201,7 @@ class GriptapeNodes(metaclass=SingletonMeta):
                 AppStartSessionRequest, self.handle_session_start_request
             )
             self._event_manager.assign_manager_to_request_type(AppEndSessionRequest, self.handle_session_end_request)
+            self._event_manager.add_listener_to_app_event(AppConnectionEstablished, self.on_app_connection_established)
             self._event_manager.assign_manager_to_request_type(AppGetSessionRequest, self.handle_get_session_request)
             self._event_manager.assign_manager_to_request_type(
                 SessionHeartbeatRequest, self.handle_session_heartbeat_request
@@ -293,6 +297,10 @@ class GriptapeNodes(metaclass=SingletonMeta):
     def ConfigManager(cls) -> ConfigManager:
         return GriptapeNodes.get_instance()._config_manager
 
+    @classmethod
+    def OSManager(cls) -> OSManager:
+        return GriptapeNodes.get_instance()._os_manager
+
     @classmethod
     def SecretsManager(cls) -> SecretsManager:
         return GriptapeNodes.get_instance()._secrets_manager
@@ -344,6 +352,27 @@ class GriptapeNodes(metaclass=SingletonMeta):
             msg = "Failed to successfully delete all objects"
             raise ValueError(msg)
 
+    def on_app_connection_established(self, _payload: AppConnectionEstablished) -> None:
+        from griptape_nodes.app.app import subscribe_to_topic
+
+        # Subscribe to request topic (engine discovery)
+        subscribe_to_topic("request")
+
+        # Get engine ID and subscribe to engine_id/request
+        engine_id = GriptapeNodes.get_engine_id()
+        if engine_id:
+            subscribe_to_topic(f"engines/{engine_id}/request")
+        else:
+            logger.warning("Engine ID not available for subscription")
+
+        # Get session ID and subscribe to session_id/request if available
+        session_id = GriptapeNodes.get_session_id()
+        if session_id:
+            topic = f"sessions/{session_id}/request"
+            subscribe_to_topic(topic)
+        else:
+            logger.info("No session ID available for subscription")
+
     def handle_engine_version_request(self, request: GetEngineVersionRequest) -> ResultPayload:  # noqa: ARG002
         try:
             engine_ver = Version.from_string(engine_version)
@@ -362,6 +391,8 @@ class GriptapeNodes(metaclass=SingletonMeta):
             return GetEngineVersionResultFailure()
 
     def handle_session_start_request(self, request: AppStartSessionRequest) -> ResultPayload:  # noqa: ARG002
+        from griptape_nodes.app.app import subscribe_to_topic
+
         current_session_id = GriptapeNodes.SessionManager().get_active_session_id()
         if current_session_id is None:
             # Client wants a new session
@@ -372,9 +403,15 @@ class GriptapeNodes(metaclass=SingletonMeta):
         else:
             details = f"Session '{current_session_id}' already active. Joining..."
 
+        topic = f"sessions/{current_session_id}/request"
+        subscribe_to_topic(topic)
+        logger.info("Subscribed to new session topic: %s", topic)
+
         return AppStartSessionResultSuccess(current_session_id)
 
     def handle_session_end_request(self, _: AppEndSessionRequest) -> ResultPayload:
+        from griptape_nodes.app.app import unsubscribe_from_topic
+
         try:
             previous_session_id = GriptapeNodes.SessionManager().get_active_session_id()
             if previous_session_id is None:
@@ -385,6 +422,9 @@ class GriptapeNodes(metaclass=SingletonMeta):
                 logger.info(details)
                 GriptapeNodes.SessionManager().clear_saved_session()
 
+            unsubscribe_topic = f"sessions/{previous_session_id}/request"
+            unsubscribe_from_topic(unsubscribe_topic)
+
             return AppEndSessionResultSuccess(session_id=previous_session_id)
         except Exception as err:
             details = f"Failed to end session due to '{err}'."
@@ -485,45 +525,8 @@ class GriptapeNodes(metaclass=SingletonMeta):
         # Determine deployment type based on presence of instance environment variables
         instance_info["deployment_type"] = "griptape_hosted" if any(instance_info.values()) else "local"
 
-        # Get public IP address
-        public_ip = self._get_public_ip()
-        if public_ip:
-            instance_info["public_ip"] = public_ip
-
         return instance_info
 
-    def _get_public_ip(self) -> str | None:
-        """Get the public IP address of this device.
-
-        Returns the public IP address if available, None otherwise.
-        """
-        try:
-            # Try multiple services in case one is down
-            services = [
-                "https://api.ipify.org",
-                "https://ipinfo.io/ip",
-                "https://icanhazip.com",
-            ]
-
-            for service in services:
-                try:
-                    with httpx.Client(timeout=5.0) as client:
-                        response = client.get(service)
-                        response.raise_for_status()
-                        public_ip = response.text.strip()
-                        if public_ip:
-                            logger.debug("Retrieved public IP from %s: %s", service, public_ip)
-                            return public_ip
-                except Exception as err:
-                    logger.debug("Failed to get public IP from %s: %s", service, err)
-                    continue
-            logger.warning("Unable to retrieve public IP from any service")
-        except Exception as err:
-            logger.warning("Failed to get public IP: %s", err)
-            return None
-        else:
-            return None
-
     def _get_current_workflow_info(self) -> dict[str, Any]:
         """Get information about the currently loaded workflow.
 

griptape_nodes/retained_mode/managers/agent_manager.py

@@ -1,7 +1,9 @@
 import json
 import logging
+import os
 import threading
 import uuid
+from typing import TYPE_CHECKING
 
 from attrs import define, field
 from griptape.artifacts import ErrorArtifact, ImageUrlArtifact, JsonArtifact
@@ -14,6 +16,7 @@ from griptape.memory.structure import ConversationMemory
 from griptape.rules import Rule, Ruleset
 from griptape.structures import Agent
 from griptape.tools import BaseImageGenerationTool
+from griptape.tools.mcp.tool import MCPTool
 from griptape.utils.decorators import activity
 from json_repair import repair_json
 from schema import Literal, Schema
@@ -42,10 +45,14 @@ from griptape_nodes.retained_mode.managers.static_files_manager import (
     StaticFilesManager,
 )
 
+if TYPE_CHECKING:
+    from griptape.tools.mcp.sessions import StreamableHttpConnection
+
 logger = logging.getLogger("griptape_nodes")
 
 API_KEY_ENV_VAR = "GT_CLOUD_API_KEY"
 SERVICE = "Griptape"
+GTN_MCP_SERVER_PORT = int(os.getenv("GTN_MCP_SERVER_PORT", "9927"))
 
 config_manager = ConfigManager()
 secrets_manager = SecretsManager(config_manager)
@@ -84,6 +91,7 @@ class AgentManager:
         self.conversation_memory = ConversationMemory()
         self.prompt_driver = None
         self.image_tool = None
+        self.mcp_tool = None
         self.static_files_manager = static_files_manager
 
         if event_manager is not None:
@@ -113,14 +121,53 @@ class AgentManager:
             static_files_manager=self.static_files_manager,
         )
 
+    def _initialize_mcp_tool(self) -> MCPTool:
+        connection: StreamableHttpConnection = {  # type: ignore[reportAssignmentType]
+            "transport": "streamable_http",
+            "url": f"http://localhost:{GTN_MCP_SERVER_PORT}/mcp/",
+        }
+        return MCPTool(connection=connection)
+
     def on_handle_run_agent_request(self, request: RunAgentRequest) -> ResultPayload:
         if self.prompt_driver is None:
             self.prompt_driver = self._initialize_prompt_driver()
         if self.image_tool is None:
             self.image_tool = self._initialize_image_tool()
+        if self.mcp_tool is None:
+            self.mcp_tool = self._initialize_mcp_tool()
         threading.Thread(target=self._on_handle_run_agent_request, args=(request, EventBus.event_listeners)).start()
         return RunAgentResultStarted()
 
+    def _create_agent(self) -> Agent:
+        output_schema = Schema(
+            {
+                "generated_image_urls": [str],
+                "conversation_output": str,
+            }
+        )
+
+        tools = []
+        if self.image_tool is not None:
+            tools.append(self.image_tool)
+        if self.mcp_tool is not None:
+            tools.append(self.mcp_tool)
+
+        return Agent(
+            prompt_driver=self.prompt_driver,
+            conversation_memory=self.conversation_memory,
+            tools=tools,
+            output_schema=output_schema,
+            rulesets=[
+                Ruleset(
+                    name="generated_image_urls",
+                    rules=[
+                        Rule("Do not hallucinate generated_image_urls."),
+                        Rule("Only set generated_image_urls with images generated with your tools."),
+                    ],
+                ),
+            ],
+        )
+
     def _on_handle_run_agent_request(
         self, request: RunAgentRequest, event_listeners: list[EventListener]
     ) -> ResultPayload:
@@ -131,28 +178,7 @@ class AgentManager:
                 for url_artifact in request.url_artifacts
                 if url_artifact["type"] == "ImageUrlArtifact"
             ]
-
-            output_schema = Schema(
-                {
-                    "generated_image_urls": [str],
-                    "conversation_output": str,
-                }
-            )
-            agent = Agent(
-                prompt_driver=self.prompt_driver,
-                conversation_memory=self.conversation_memory,
-                tools=[self.image_tool] if self.image_tool else [],
-                output_schema=output_schema,
-                rulesets=[
-                    Ruleset(
-                        name="generated_image_urls",
-                        rules=[
-                            Rule("Do not hallucinate generated_image_urls."),
-                            Rule("Only set generated_image_urls with images generated with your tools."),
-                        ],
-                    ),
-                ],
-            )
+            agent = self._create_agent()
             *events, last_event = agent.run_stream([request.input, *artifacts])
             full_result = ""
             last_conversation_output = ""

griptape_nodes/retained_mode/managers/flow_manager.py

@@ -1810,6 +1810,8 @@ class FlowManager:
     def unresolve_whole_flow(self, flow: ControlFlow) -> None:
         for node in flow.nodes.values():
             node.make_node_unresolved(current_states_to_trigger_change_event=None)
+            # Clear entry control parameter for new execution
+            node.set_entry_control_parameter(None)
 
     def flow_state(self, flow: ControlFlow) -> tuple[str | None, str | None]:  # noqa: ARG002
         if not self.check_for_existing_running_flow():

griptape_nodes/retained_mode/managers/library_lifecycle/__init__.py

@@ -0,0 +1,45 @@
+"""Library lifecycle management subsystem."""
+
+from griptape_nodes.retained_mode.managers.library_lifecycle.data_models import (
+    EvaluationResult,
+    InspectionResult,
+    InstallationResult,
+    LibraryByType,
+    LibraryEntry,
+    LibraryLoadedResult,
+    LibraryPreferences,
+    LifecycleIssue,
+)
+from griptape_nodes.retained_mode.managers.library_lifecycle.library_directory import LibraryDirectory
+from griptape_nodes.retained_mode.managers.library_lifecycle.library_fsm import (
+    LibraryLifecycleContext,
+    LibraryLifecycleFSM,
+)
+from griptape_nodes.retained_mode.managers.library_lifecycle.library_provenance import (
+    LibraryProvenance,
+    LibraryProvenanceGitHub,
+    LibraryProvenanceLocalFile,
+    LibraryProvenancePackage,
+    LibraryProvenanceSandbox,
+)
+from griptape_nodes.retained_mode.managers.library_lifecycle.library_status import LibraryStatus
+
+__all__ = [
+    "EvaluationResult",
+    "InspectionResult",
+    "InstallationResult",
+    "LibraryByType",
+    "LibraryDirectory",
+    "LibraryEntry",
+    "LibraryLifecycleContext",
+    "LibraryLifecycleFSM",
+    "LibraryLoadedResult",
+    "LibraryPreferences",
+    "LibraryProvenance",
+    "LibraryProvenanceGitHub",
+    "LibraryProvenanceLocalFile",
+    "LibraryProvenancePackage",
+    "LibraryProvenanceSandbox",
+    "LibraryStatus",
+    "LifecycleIssue",
+]