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

griptape_nodes/retained_mode/managers/resource_types/cpu_resource.py

@@ -0,0 +1,108 @@
+import logging
+from typing import TYPE_CHECKING, Any, Literal
+
+from griptape_nodes.retained_mode.managers.resource_components.capability_field import (
+    CapabilityField,
+    validate_capabilities,
+)
+from griptape_nodes.retained_mode.managers.resource_components.resource_instance import ResourceInstance
+from griptape_nodes.retained_mode.managers.resource_components.resource_type import ResourceType
+
+if TYPE_CHECKING:
+    from griptape_nodes.retained_mode.managers.resource_components.resource_instance import Requirements
+
+logger = logging.getLogger("griptape_nodes")
+
+
+# CPU capability field names
+CPUCapability = Literal[
+    "cores",
+    "threads",
+    "architecture",
+    "clock_speed_ghz",
+]
+
+
+class CPUInstance(ResourceInstance):
+    """Resource instance representing CPU compute resources."""
+
+    def can_be_freed(self) -> bool:
+        """CPU resources can typically be freed when not in use."""
+        return True
+
+    def free(self) -> None:
+        """Free CPU resource instance."""
+        logger.debug("Freeing CPU resource instance %s", self.get_instance_id())
+
+    def get_capability_typed(self, key: CPUCapability) -> Any:
+        """Type-safe capability getter using Literal types."""
+        return self.get_capability_value(key)
+
+
+class CPUResourceType(ResourceType):
+    """Resource type for CPU compute resources."""
+
+    def get_capability_schema(self) -> list[CapabilityField]:
+        """Get the capability schema for CPU resources."""
+        return [
+            CapabilityField(
+                name="cores",
+                type_hint=int,
+                description="Number of CPU cores",
+                required=True,
+            ),
+            CapabilityField(
+                name="threads",
+                type_hint=int,
+                description="Number of threads (with hyperthreading)",
+                required=False,
+            ),
+            CapabilityField(
+                name="architecture",
+                type_hint=str,
+                description="CPU architecture: 'x86_64', 'arm64', 'aarch64'",
+                required=True,
+            ),
+            CapabilityField(
+                name="clock_speed_ghz",
+                type_hint=float,
+                description="Base clock speed in GHz",
+                required=False,
+            ),
+        ]
+
+    def create_instance(self, capabilities: dict[str, Any]) -> ResourceInstance:
+        """Create a new CPU resource instance."""
+        # Validate capabilities against schema
+        validation_errors = validate_capabilities(self.get_capability_schema(), capabilities)
+        if validation_errors:
+            error_msg = f"Invalid CPU capabilities: {', '.join(validation_errors)}"
+            raise ValueError(error_msg)
+
+        return CPUInstance(resource_type=self, instance_id_prefix="cpu", capabilities=capabilities)
+
+    def select_best_compatible_instance(
+        self, compatible_instances: list[ResourceInstance], _requirements: "Requirements | None" = None
+    ) -> ResourceInstance | None:
+        """Select the best CPU instance from compatible ones.
+
+        Prioritizes CPUs with:
+        1. More cores
+        2. Higher clock speed
+        """
+        if not compatible_instances:
+            return None
+
+        def sort_key(instance: ResourceInstance) -> tuple[int, float]:
+            # More cores is better
+            cores = instance.get_capability_value("cores") if instance.has_capability("cores") else 1
+
+            # Higher clock speed is better
+            clock_speed = (
+                instance.get_capability_value("clock_speed_ghz") if instance.has_capability("clock_speed_ghz") else 0
+            )
+
+            return (int(cores), float(clock_speed))
+
+        sorted_instances = sorted(compatible_instances, key=sort_key, reverse=True)
+        return sorted_instances[0]

griptape_nodes/retained_mode/managers/resource_types/os_resource.py

@@ -0,0 +1,87 @@
+import logging
+from typing import TYPE_CHECKING, Any, Literal
+
+from griptape_nodes.retained_mode.managers.resource_components.capability_field import (
+    CapabilityField,
+    validate_capabilities,
+)
+from griptape_nodes.retained_mode.managers.resource_components.resource_instance import ResourceInstance
+from griptape_nodes.retained_mode.managers.resource_components.resource_type import ResourceType
+
+if TYPE_CHECKING:
+    from griptape_nodes.retained_mode.managers.resource_components.resource_instance import Requirements
+
+logger = logging.getLogger("griptape_nodes")
+
+
+# OS capability field names
+OSCapability = Literal[
+    "platform",
+    "arch",
+    "version",
+]
+
+
+class OSInstance(ResourceInstance):
+    """Resource instance representing an operating system environment."""
+
+    def can_be_freed(self) -> bool:
+        """OS resources can be freed when no longer needed."""
+        return True
+
+    def free(self) -> None:
+        """Free OS resource instance."""
+        logger.debug("Freeing OS resource instance %s", self.get_instance_id())
+
+    def get_capability_typed(self, key: OSCapability) -> Any:
+        """Type-safe capability getter using Literal types."""
+        return self.get_capability_value(key)
+
+
+class OSResourceType(ResourceType):
+    """Resource type for operating system environments."""
+
+    def get_capability_schema(self) -> list[CapabilityField]:
+        """Get the capability schema for OS resources."""
+        return [
+            CapabilityField(
+                name="platform",
+                type_hint=str,
+                description="Operating system platform: 'linux', 'darwin', 'windows'",
+                required=True,
+            ),
+            CapabilityField(
+                name="arch",
+                type_hint=str,
+                description="System architecture: 'x86_64', 'arm64', 'aarch64'",
+                required=True,
+            ),
+            CapabilityField(
+                name="version",
+                type_hint=str,
+                description="Operating system version string",
+                required=False,
+            ),
+        ]
+
+    def create_instance(self, capabilities: dict[str, Any]) -> ResourceInstance:
+        """Create a new OS resource instance."""
+        # Validate capabilities against schema
+        validation_errors = validate_capabilities(self.get_capability_schema(), capabilities)
+        if validation_errors:
+            error_msg = f"Invalid OS capabilities: {', '.join(validation_errors)}"
+            raise ValueError(error_msg)
+
+        return OSInstance(resource_type=self, instance_id_prefix="os", capabilities=capabilities)
+
+    def select_best_compatible_instance(
+        self, compatible_instances: list[ResourceInstance], _requirements: "Requirements | None" = None
+    ) -> ResourceInstance | None:
+        """Select the best OS instance from compatible ones.
+
+        Returns the first compatible instance (no special selection criteria for now).
+        """
+        if not compatible_instances:
+            return None
+
+        return compatible_instances[0]

griptape_nodes/retained_mode/managers/settings.py

@@ -23,6 +23,7 @@ API_KEYS = Category(name="API Keys", description="API keys and authentication cr
 EXECUTION = Category(name="Execution", description="Workflow execution and processing settings")
 STORAGE = Category(name="Storage", description="Data storage and persistence configuration")
 SYSTEM_REQUIREMENTS = Category(name="System Requirements", description="System resource requirements and limits")
+MCP_SERVERS = Category(name="MCP Servers", description="Model Context Protocol server configurations")
 
 
 def Field(category: str | Category = "General", **kwargs) -> Any:
@@ -56,6 +57,40 @@ class LogLevel(StrEnum):
     DEBUG = "DEBUG"
 
 
+class MCPServerConfig(BaseModel):
+    """Configuration for a single MCP server."""
+
+    name: str = Field(description="Unique name/identifier for the MCP server")
+    enabled: bool = Field(default=True, description="Whether this MCP server is enabled")
+    transport: str = Field(default="stdio", description="Transport type: stdio, sse, streamable_http, or websocket")
+
+    # StdioConnection fields
+    command: str | None = Field(default=None, description="Command to start the MCP server (required for stdio)")
+    args: list[str] = Field(default_factory=list, description="Arguments to pass to the MCP server command (stdio)")
+    env: dict[str, str] = Field(default_factory=dict, description="Environment variables for the MCP server (stdio)")
+    cwd: str | None = Field(default=None, description="Working directory for the MCP server (stdio)")
+    encoding: str = Field(default="utf-8", description="Text encoding for stdio communication")
+    encoding_error_handler: str = Field(default="strict", description="Encoding error handler for stdio")
+
+    # HTTP-based connection fields (sse, streamable_http, websocket)
+    url: str | None = Field(
+        default=None, description="URL for HTTP-based connections (sse, streamable_http, websocket)"
+    )
+    headers: dict[str, str] | None = Field(default=None, description="HTTP headers for HTTP-based connections")
+    timeout: float | None = Field(default=None, description="HTTP timeout in seconds")
+    sse_read_timeout: float | None = Field(default=None, description="SSE read timeout in seconds")
+    terminate_on_close: bool = Field(
+        default=True, description="Whether to terminate session on close (streamable_http)"
+    )
+
+    # Common fields
+    description: str | None = Field(default=None, description="Optional description of what this MCP server provides")
+    capabilities: list[str] = Field(default_factory=list, description="List of capabilities this MCP server provides")
+
+    def __str__(self) -> str:
+        return f"{self.name} ({'enabled' if self.enabled else 'disabled'})"
+
+
 class AppInitializationComplete(BaseModel):
     libraries_to_register: list[str] = Field(default_factory=list)
     workflows_to_register: list[str] = Field(default_factory=list)
@@ -210,3 +245,13 @@ class Settings(BaseModel):
         default="synced_workflows",
         description="Path to the synced workflows directory, relative to the workspace directory.",
     )
+    enable_workspace_file_watching: bool = Field(
+        category=FILE_SYSTEM,
+        default=True,
+        description="Enable file watching for synced workflows directory",
+    )
+    mcp_servers: list[MCPServerConfig] = Field(
+        category=MCP_SERVERS,
+        default_factory=list,
+        description="List of Model Context Protocol server configurations",
+    )

griptape_nodes/retained_mode/managers/sync_manager.py

@@ -164,8 +164,15 @@ class SyncManager:
         try:
             # Check if cloud storage is configured before attempting sync
             self._get_cloud_storage_driver()
-            # Start file watching after successful sync
-            self._start_file_watching()
+
+            # Check if file watching is enabled before starting it
+            enable_file_watching = self._config_manager.get_config_value("enable_workspace_file_watching", default=True)
+            if enable_file_watching:
+                # Start file watching after successful sync
+                self._start_file_watching()
+                logger.debug("File watching enabled - started watching synced workflows directory")
+            else:
+                logger.debug("File watching disabled - skipping file watching startup")
 
             logger.info("App initialization complete - starting automatic cloud workflow sync")
 
@@ -449,7 +456,7 @@ class SyncManager:
 
             # Collect results as they complete
             for future in future_to_filename:
-                filename, success, error = future.result()
+                filename, success, _error = future.result()
                 if success:
                     synced_workflows.append(filename)
                 else: