griptape-nodes 0.65.5__py3-none-any.whl → 0.66.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/node_manager.py

@@ -3081,9 +3081,15 @@ class NodeManager:
         if parameter.name in node.parameter_output_values:
             # Output values are more important.
             output_value = node.parameter_output_values[parameter.name]
-        if parameter.name in node.parameter_values:
-            # Check the internal parameter values
-            internal_value = node.get_parameter_value(parameter.name)
+        # Get the effective value to check if it matches the default
+        effective_value = node.get_parameter_value(parameter.name)
+        # Save the value if it was explicitly set OR if it equals the default value.
+        # The latter ensures the default is preserved when loading workflows,
+        # even if the code's default value changes later.
+        if parameter.name in node.parameter_values or (
+            parameter.default_value is not None and effective_value == parameter.default_value
+        ):
+            internal_value = effective_value
         # We have a value. Attempt to get a hash for it to see if it matches one
         # we've already indexed.
         commands = []

griptape_nodes/retained_mode/managers/os_manager.py

@@ -21,7 +21,6 @@ from griptape_nodes.common.macro_parser.exceptions import MacroResolutionFailure
 from griptape_nodes.common.macro_parser.formats import NumericPaddingFormat
 from griptape_nodes.common.macro_parser.resolution import partial_resolve
 from griptape_nodes.common.macro_parser.segments import ParsedStaticValue, ParsedVariable
-from griptape_nodes.retained_mode.events.app_events import AppInitializationComplete
 from griptape_nodes.retained_mode.events.base_events import ResultDetails, ResultPayload
 from griptape_nodes.retained_mode.events.os_events import (
     CopyFileRequest,
@@ -70,8 +69,9 @@ from griptape_nodes.retained_mode.events.resource_events import (
 )
 from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes, logger
 from griptape_nodes.retained_mode.managers.event_manager import EventManager
+from griptape_nodes.retained_mode.managers.resource_types.compute_resource import ComputeBackend, ComputeResourceType
 from griptape_nodes.retained_mode.managers.resource_types.cpu_resource import CPUResourceType
-from griptape_nodes.retained_mode.managers.resource_types.os_resource import OSResourceType
+from griptape_nodes.retained_mode.managers.resource_types.os_resource import Architecture, OSResourceType, Platform
 
 console = Console()
 
@@ -218,8 +218,13 @@ class OSManager:
                 request_type=GetFileInfoRequest, callback=self.on_get_file_info_request
             )
 
-            # Register for app initialization event to setup system resources
-            event_manager.add_listener_to_app_event(AppInitializationComplete, self.on_app_initialization_complete)
+            # Store event_manager for direct access during resource registration
+            self._event_manager = event_manager
+
+            # Register system resources immediately using the event_manager directly
+            # This must happen before libraries are loaded so they can check requirements
+            # We use event_manager directly to avoid singleton recursion issues
+            self._register_system_resources_direct()
 
     def _get_workspace_path(self) -> Path:
         """Get the workspace path from config."""
@@ -462,8 +467,14 @@ class OSManager:
             return path_str[1:-1]
         return path_str
 
-    def sanitize_path_string(self, path_str: str) -> str:
-        r"""Strip surrounding quotes and shell escape characters from paths.
+    def sanitize_path_string(self, path: str | Path | Any) -> str | Any:
+        r"""Clean path strings by removing newlines, carriage returns, shell escapes, and quotes.
+
+        This method handles multiple path cleaning concerns:
+        1. Removes newlines/carriage returns that cause WinError 123 on Windows
+           (from merge_texts nodes accidentally adding newlines between path components)
+        2. Removes shell escape characters and quotes (from macOS Finder 'Copy as Pathname')
+        3. Strips leading/trailing whitespace
 
         Handles macOS Finder's 'Copy as Pathname' format which escapes
         spaces, apostrophes, and other special characters with backslashes.
@@ -471,7 +482,7 @@ class OSManager:
         breaking Windows paths like C:\Users\file.txt.
 
         Examples:
-            macOS Finder paths (the reason this exists!):
+            macOS Finder paths:
                 "/Downloads/Dragon\'s\ Curse/screenshot.jpg"
                 -> "/Downloads/Dragon's Curse/screenshot.jpg"
 
@@ -482,22 +493,33 @@ class OSManager:
                 '"/path/with spaces/file.txt"'
                 -> "/path/with spaces/file.txt"
 
-            Windows paths (preserved correctly):
-                "C:\Users\Desktop\file.txt"
-                -> "C:\Users\Desktop\file.txt"
+            Windows paths with newlines:
+                "C:\\Users\\file\\n\\n.txt"
+                -> "C:\\Users\\file.txt"
 
             Windows extended-length paths:
                 r"\\?\C:\Very\ Long\ Path\file.txt"
                 -> r"\\?\C:\Very Long Path\file.txt"
 
+            Path objects:
+                Path("/path/to/file")
+                -> "/path/to/file"
+
         Args:
-            path_str: The path string to sanitize
+            path: Path string, Path object, or any other type to sanitize
 
         Returns:
-            Sanitized path string
+            Sanitized path string, or original value if not a string/Path
         """
+        # Convert Path objects to strings
+        if isinstance(path, Path):
+            path = str(path)
+
+        if not isinstance(path, str):
+            return path
+
         # First, strip surrounding quotes
-        path_str = OSManager.strip_surrounding_quotes(path_str)
+        path_str = OSManager.strip_surrounding_quotes(path)
 
         # Handle Windows extended-length paths (\\?\...) specially
         # These are used for paths longer than 260 characters on Windows
@@ -512,6 +534,12 @@ class OSManager:
         # Does NOT match: \U \t \f etc in Windows paths like C:\Users
         path_str = re.sub(r"\\([ '\"(){}[\]&|;<>$`!*?/])", r"\1", path_str)
 
+        # Remove newlines and carriage returns from anywhere in the path
+        path_str = path_str.replace("\n", "").replace("\r", "")
+
+        # Strip leading/trailing whitespace
+        path_str = path_str.strip()
+
         # Restore extended-length prefix if it was present
         if extended_length_prefix:
             path_str = extended_length_prefix + path_str
@@ -525,6 +553,8 @@ class OSManager:
         need the \\?\ prefix to work correctly. This method transparently adds
         the prefix when needed on Windows.
 
+        Also cleans paths to remove newlines/carriage returns that cause Windows errors.
+
         Note: This method assumes the path exists or will exist. For non-existent
         paths that need cross-platform normalization, use resolve_path_safely() first.
 
@@ -532,10 +562,15 @@ class OSManager:
             path: Path object to convert to string
 
         Returns:
-            String representation of path, with Windows long path prefix if needed
+            String representation of path, cleaned of newlines/carriage returns,
+            with Windows long path prefix if needed
         """
         path_str = str(path.resolve())
 
+        # Clean path to remove newlines/carriage returns, shell escapes, and quotes
+        # This handles cases where merge_texts nodes accidentally add newlines between path components
+        path_str = self.sanitize_path_string(path_str)
+
         # Windows long path handling (paths > WINDOWS_MAX_PATH chars need \\?\ prefix)
         if self.is_windows() and len(path_str) >= WINDOWS_MAX_PATH and not path_str.startswith("\\\\?\\"):
             # UNC paths (\\server\share) need \\?\UNC\ prefix
@@ -1110,22 +1145,55 @@ class OSManager:
             logger.error(details)
             return OpenAssociatedFileResultFailure(failure_reason=FileIOFailureReason.UNKNOWN, result_details=details)
 
+    def _is_hidden(self, dir_entry: os.DirEntry, stat_result: os.stat_result | None = None) -> bool:
+        """Check if a directory entry is hidden in an OS-independent way.
+
+        On Unix/Linux/macOS: Files are considered hidden if their name starts with a dot (.).
+        On Windows: Files have a special "hidden" file attribute (FILE_ATTRIBUTE_HIDDEN).
+
+        Args:
+            dir_entry: The directory entry to check
+            stat_result: Optional pre-fetched stat result (to avoid redundant stat() calls on Windows)
+
+        Returns:
+            True if the entry is hidden, False otherwise
+        """
+        if sys.platform == "win32":
+            # Windows: Check name prefix first (fast heuristic for most hidden files)
+            # Most hidden files on Windows have dot prefix, so this avoids many stat() calls
+            if dir_entry.name.startswith("."):
+                return True
+            # For files without dot prefix, check FILE_ATTRIBUTE_HIDDEN via stat()
+            if stat_result is None:
+                stat_result = dir_entry.stat(follow_symlinks=False)
+            return bool(stat_result.st_file_attributes & stat.FILE_ATTRIBUTE_HIDDEN)
+        # Unix/Linux/macOS: Files are hidden if name starts with dot
+        return dir_entry.name.startswith(".")
+
     def _detect_mime_type(self, file_path: Path) -> str | None:
-        """Detect MIME type for a file. Returns None for directories or if detection fails."""
+        """Detect MIME type for a file. Returns None for directories or if detection fails.
+
+        Args:
+            file_path: Original file path (used for is_dir() check and filename extraction)
+        """
         if file_path.is_dir():
             return None
 
+        # mimetypes.guess_type() only needs the filename, not the full path
+        # Using just the filename is ~2x faster and avoids path normalization overhead
+        filename = file_path.name
         try:
-            mime_type, _ = mimetypes.guess_type(self.normalize_path_for_platform(file_path), strict=True)
-            if mime_type is None:
-                mime_type = "text/plain"
-            return mime_type  # noqa: TRY300
+            mime_type, _ = mimetypes.guess_type(filename, strict=True)
         except Exception as e:
-            msg = f"MIME type detection failed for {file_path}: {e}"
+            msg = f"MIME type detection failed for {file_path} (filename: {filename}): {e}"
             logger.warning(msg)
             return "text/plain"
 
-    def on_list_directory_request(self, request: ListDirectoryRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912
+        if mime_type is None:
+            mime_type = "text/plain"
+        return mime_type
+
+    def on_list_directory_request(self, request: ListDirectoryRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912, PLR0915
         """Handle a request to list directory contents."""
         try:
             # Get the directory path to list
@@ -1156,40 +1224,112 @@ class OSManager:
                 logger.error(msg)
                 return ListDirectoryResultFailure(failure_reason=FileIOFailureReason.INVALID_PATH, result_details=msg)
 
+            # Cache workspace path and resolved workspace to avoid repeated lookups/resolutions
+            # Only resolve workspace if we need it for relative paths or absolute paths
+            need_relative_paths = request.workspace_only is True
+            workspace_path = GriptapeNodes.ConfigManager().workspace_path
+            if need_relative_paths or request.include_absolute_path:
+                resolved_workspace = workspace_path.resolve()
+            else:
+                resolved_workspace = None
+
             entries = []
             try:
-                # List directory contents
-                for entry in directory.iterdir():
-                    # Skip hidden files if not requested
-                    if not request.show_hidden and entry.name.startswith("."):
-                        continue
-
-                    # Apply pattern filter if specified
-                    if request.pattern is not None and not entry.match(request.pattern):
-                        continue
+                # Pre-compute whether we need stat() calls (constant for all entries)
+                need_stat_for_metadata = request.include_size or request.include_modified_time
+                # On Windows, we need stat() to check FILE_ATTRIBUTE_HIDDEN when filtering hidden files
+                # (only for files without dot prefix, since dot-prefix files are handled by name check)
+                need_stat_for_hidden = not request.show_hidden and sys.platform == "win32"
+
+                # Use os.scandir() instead of Path.iterdir() for better performance
+                # os.scandir() is ~3.7x faster and provides cached stat info
+                with os.scandir(str(directory)) as scan_iter:
+                    for dir_entry in scan_iter:
+                        # Initialize stat - we'll get it once if needed for hidden check and/or metadata
+                        stat = None
+
+                        # Skip hidden files if not requested (OS-independent check)
+                        if not request.show_hidden:
+                            # On Windows, files without dot prefix need stat() to check FILE_ATTRIBUTE_HIDDEN
+                            # Get stat() once if needed (for hidden check and/or metadata)
+                            if need_stat_for_hidden and not dir_entry.name.startswith("."):
+                                stat = dir_entry.stat(follow_symlinks=False)
+
+                            if self._is_hidden(dir_entry, stat_result=stat):
+                                continue
+
+                        # Apply pattern filter if specified, or create Path object if needed
+                        if request.pattern is not None:
+                            # Convert DirEntry to Path for pattern matching
+                            entry_path_obj = Path(dir_entry.path)
+                            if not entry_path_obj.match(request.pattern):
+                                continue
+                        elif request.include_absolute_path or request.include_mime_type or need_relative_paths:
+                            # Only create Path object if we need it
+                            entry_path_obj = Path(dir_entry.path)
+                        else:
+                            entry_path_obj = None
 
-                    try:
-                        stat = entry.stat()
-                        # Get path relative to workspace if within workspace
-                        _, entry_path = self._validate_workspace_path(entry)
-                        # Also get absolute resolved path
-                        absolute_resolved_path = str(entry.resolve())
-                        mime_type = self._detect_mime_type(entry)
-                        entries.append(
-                            FileSystemEntry(
-                                name=entry.name,
-                                path=str(entry_path),
-                                is_dir=entry.is_dir(),
-                                size=stat.st_size,
-                                modified_time=stat.st_mtime,
-                                mime_type=mime_type,
-                                absolute_path=absolute_resolved_path,
+                        try:
+                            # Get stat() if needed for metadata (reuse if we already have it from hidden check)
+                            if need_stat_for_metadata and stat is None:
+                                stat = dir_entry.stat(follow_symlinks=False)
+
+                            # Only resolve entry path if we need absolute_path or relative paths
+                            resolved_entry = None
+                            absolute_resolved_path = ""
+                            if request.include_absolute_path or need_relative_paths:
+                                if entry_path_obj is None:
+                                    entry_path_obj = Path(dir_entry.path)
+                                resolved_entry = entry_path_obj.resolve()
+                                absolute_resolved_path = str(resolved_entry) if request.include_absolute_path else ""
+
+                            # Determine entry_path based on what we need
+                            if need_relative_paths and resolved_entry is not None and resolved_workspace is not None:
+                                try:
+                                    relative = resolved_entry.relative_to(resolved_workspace)
+                                    entry_path = relative
+                                except ValueError:
+                                    # Entry is outside workspace
+                                    entry_path = resolved_entry
+                            elif request.include_absolute_path and resolved_entry is not None:
+                                entry_path = resolved_entry
+                            else:
+                                # Use the path from dir_entry (may be relative or absolute depending on system)
+                                entry_path = dir_entry.path
+
+                            # Only detect MIME type if requested
+                            mime_type = None
+                            if request.include_mime_type:
+                                if entry_path_obj is None:
+                                    entry_path_obj = Path(dir_entry.path)
+                                # Use resolved_entry if available, otherwise just entry_path_obj
+                                mime_type = self._detect_mime_type(entry_path_obj)
+
+                            # Determine size and modified_time values
+                            entry_size = 0
+                            if stat and request.include_size:
+                                entry_size = stat.st_size
+
+                            entry_modified_time = 0.0
+                            if stat and request.include_modified_time:
+                                entry_modified_time = stat.st_mtime
+
+                            entries.append(
+                                FileSystemEntry(
+                                    name=dir_entry.name,
+                                    path=str(entry_path),
+                                    is_dir=dir_entry.is_dir(),
+                                    size=entry_size,
+                                    modified_time=entry_modified_time,
+                                    mime_type=mime_type,
+                                    absolute_path=absolute_resolved_path,
+                                )
                             )
-                        )
-                    except (OSError, PermissionError) as e:
-                        msg = f"Could not stat entry {entry}: {e}"
-                        logger.warning(msg)
-                        continue
+                        except (OSError, PermissionError) as e:
+                            msg = f"Could not process entry {dir_entry.name}: {e}"
+                            logger.warning(msg)
+                            continue
 
             except PermissionError as e:
                 msg = f"Permission denied listing directory {directory}: {e}"
@@ -2735,15 +2875,132 @@ class OSManager:
             result_details=f"Directory tree copied successfully: {source_path} -> {destination_path}",
         )
 
-    def on_app_initialization_complete(self, _payload: AppInitializationComplete) -> None:
-        """Handle app initialization complete event by registering system resources."""
-        self._register_system_resources()
+    # Resource Management Methods
+    def _register_system_resources_direct(self) -> None:
+        """Register OS, CPU, and Compute resource types directly during initialization.
+
+        This method is called during __init__ and uses the event_manager directly
+        to avoid singleton recursion issues with GriptapeNodes.handle_request.
+        """
+        self._attempt_generate_os_resources_direct()
+        self._attempt_generate_cpu_resources_direct()
+        self._attempt_generate_compute_resources_direct()
+
+    def _handle_request_direct(self, request: Any) -> Any:
+        """Handle a request directly through the event_manager during initialization.
+
+        This bypasses GriptapeNodes.handle_request to avoid singleton recursion.
+        """
+        request_type = type(request)
+        callback = self._event_manager._request_type_to_manager.get(request_type)
+        if not callback:
+            msg = f"No manager found to handle request of type '{request_type.__name__}'."
+            raise TypeError(msg)
+        return callback(request)
 
-    # NEW Resource Management Methods
     def _register_system_resources(self) -> None:
-        """Register OS and CPU resource types with ResourceManager and create system instances."""
+        """Register OS, CPU, and Compute resource types with ResourceManager and create system instances."""
         self._attempt_generate_os_resources()
         self._attempt_generate_cpu_resources()
+        self._attempt_generate_compute_resources()
+
+    def _attempt_generate_os_resources_direct(self) -> None:
+        """Register OS resource type and create system OS instance (direct version for init)."""
+        os_resource_type = OSResourceType()
+        register_request = RegisterResourceTypeRequest(resource_type=os_resource_type)
+        result = self._handle_request_direct(register_request)
+
+        if not isinstance(result, RegisterResourceTypeResultSuccess):
+            logger.error("Attempted to register OS resource type. Failed due to resource type registration failure")
+            return
+
+        logger.debug("Successfully registered OS resource type")
+        self._create_system_os_instance_direct()
+
+    def _attempt_generate_cpu_resources_direct(self) -> None:
+        """Register CPU resource type and create system CPU instance (direct version for init)."""
+        cpu_resource_type = CPUResourceType()
+        register_request = RegisterResourceTypeRequest(resource_type=cpu_resource_type)
+        result = self._handle_request_direct(register_request)
+
+        if not isinstance(result, RegisterResourceTypeResultSuccess):
+            logger.error("Attempted to register CPU resource type. Failed due to resource type registration failure")
+            return
+
+        logger.debug("Successfully registered CPU resource type")
+        self._create_system_cpu_instance_direct()
+
+    def _attempt_generate_compute_resources_direct(self) -> None:
+        """Register Compute resource type and create system compute instance (direct version for init)."""
+        compute_resource_type = ComputeResourceType()
+        register_request = RegisterResourceTypeRequest(resource_type=compute_resource_type)
+        result = self._handle_request_direct(register_request)
+
+        if not isinstance(result, RegisterResourceTypeResultSuccess):
+            logger.error(
+                "Attempted to register Compute resource type. Failed due to resource type registration failure"
+            )
+            return
+
+        logger.debug("Successfully registered Compute resource type")
+        self._create_system_compute_instance_direct()
+
+    def _create_system_os_instance_direct(self) -> None:
+        """Create system OS instance (direct version for init)."""
+        os_capabilities = {
+            "platform": self._get_platform_name(),
+            "arch": self._get_architecture(),
+            "version": self._get_platform_version(),
+        }
+        create_request = CreateResourceInstanceRequest(
+            resource_type_name="OSResourceType", capabilities=os_capabilities
+        )
+        result = self._handle_request_direct(create_request)
+
+        if not isinstance(result, CreateResourceInstanceResultSuccess):
+            logger.error(
+                "Attempted to create system OS resource instance. Failed due to resource instance creation failure"
+            )
+            return
+
+        logger.debug("Successfully created system OS instance: %s", result.instance_id)
+
+    def _create_system_cpu_instance_direct(self) -> None:
+        """Create system CPU instance (direct version for init)."""
+        cpu_capabilities = {
+            "cores": os.cpu_count() or 1,
+            "architecture": self._get_architecture(),
+        }
+        create_request = CreateResourceInstanceRequest(
+            resource_type_name="CPUResourceType", capabilities=cpu_capabilities
+        )
+        result = self._handle_request_direct(create_request)
+
+        if not isinstance(result, CreateResourceInstanceResultSuccess):
+            logger.error(
+                "Attempted to create system CPU resource instance. Failed due to resource instance creation failure"
+            )
+            return
+
+        logger.debug("Successfully created system CPU instance: %s", result.instance_id)
+
+    def _create_system_compute_instance_direct(self) -> None:
+        """Create system compute instance with detected backends (direct version for init)."""
+        compute_capabilities = {
+            "compute": self._get_available_compute_backends(),
+        }
+        create_request = CreateResourceInstanceRequest(
+            resource_type_name="ComputeResourceType", capabilities=compute_capabilities
+        )
+        result = self._handle_request_direct(create_request)
+
+        if not isinstance(result, CreateResourceInstanceResultSuccess):
+            logger.error(
+                "Attempted to create system Compute resource instance. Failed due to resource instance creation failure"
+            )
+            return
+
+        logger.debug("Successfully created system Compute instance: %s", result.instance_id)
 
     def _attempt_generate_os_resources(self) -> None:
         """Register OS resource type and create system OS instance if successful."""
@@ -2814,23 +3071,130 @@ class OSManager:
 
         logger.debug("Successfully created system CPU instance: %s", result.instance_id)
 
+    def _attempt_generate_compute_resources(self) -> None:
+        """Register Compute resource type and create system compute instance if successful."""
+        # Register Compute resource type
+        compute_resource_type = ComputeResourceType()
+        register_request = RegisterResourceTypeRequest(resource_type=compute_resource_type)
+        result = GriptapeNodes.handle_request(register_request)
+
+        if not isinstance(result, RegisterResourceTypeResultSuccess):
+            logger.error(
+                "Attempted to register Compute resource type. Failed due to resource type registration failure"
+            )
+            return
+
+        logger.debug("Successfully registered Compute resource type")
+        # Registration successful, now create instance
+        self._create_system_compute_instance()
+
+    def _create_system_compute_instance(self) -> None:
+        """Create system compute instance with detected backends."""
+        compute_capabilities = {
+            "compute": self._get_available_compute_backends(),
+        }
+        create_request = CreateResourceInstanceRequest(
+            resource_type_name="ComputeResourceType", capabilities=compute_capabilities
+        )
+        result = GriptapeNodes.handle_request(create_request)
+
+        if not isinstance(result, CreateResourceInstanceResultSuccess):
+            logger.error(
+                "Attempted to create system Compute resource instance. Failed due to resource instance creation failure"
+            )
+            return
+
+        logger.debug("Successfully created system Compute instance: %s", result.instance_id)
+
+    def _get_available_compute_backends(self) -> list[str]:
+        """Detect available compute backends on the system.
+
+        Returns:
+            List of available backends: always includes 'cpu', plus 'cuda' or 'mps' if available.
+        """
+        backends: list[str] = [ComputeBackend.CPU]  # CPU is always available
+
+        # Check for CUDA (NVIDIA GPU)
+        if self._is_cuda_available():
+            backends.append(ComputeBackend.CUDA)
+
+        # Check for MPS (Apple Silicon)
+        if self._is_mps_available():
+            backends.append(ComputeBackend.MPS)
+
+        logger.debug("Detected compute backends: %s", backends)
+        return backends
+
+    def _is_cuda_available(self) -> bool:
+        """Check if CUDA is available by detecting NVIDIA driver.
+
+        Uses nvidia-smi command which is lightweight and doesn't require torch.
+        """
+        nvidia_smi = shutil.which("nvidia-smi")
+        if nvidia_smi is None:
+            return False
+        try:
+            result = subprocess.run(  # noqa: S603
+                [nvidia_smi, "--query-gpu=name", "--format=csv,noheader"],
+                check=False,
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            if result.returncode == 0 and result.stdout.strip():
+                logger.debug("CUDA detected via nvidia-smi: %s", result.stdout.strip().split("\n")[0])
+                return True
+        except (subprocess.TimeoutExpired, OSError):
+            pass
+        return False
+
+    def _is_mps_available(self) -> bool:
+        """Check if MPS (Metal Performance Shaders) is available.
+
+        MPS is available on Apple Silicon Macs (arm64 architecture) with macOS 12.3+.
+        """
+        if not self.is_mac():
+            return False
+
+        # Check for Apple Silicon (arm64)
+        arch = self._get_architecture()
+        if arch not in (Architecture.ARM64, Architecture.AARCH64):
+            return False
+
+        # MPS requires macOS 12.3+, but arm64 Macs shipped with 11.0+
+        # and all arm64 Macs can run 12.3+, so if it's arm64 Mac, MPS is available
+        logger.debug("MPS detected: Apple Silicon Mac")
+        return True
+
     def _get_platform_name(self) -> str:
         """Get platform name using existing sys.platform detection."""
         if self.is_windows():
-            return "windows"
+            return Platform.WINDOWS
         if self.is_mac():
-            return "darwin"
+            return Platform.DARWIN
         if self.is_linux():
-            return "linux"
+            return Platform.LINUX
         return sys.platform
 
     def _get_architecture(self) -> str:
-        """Get system architecture."""
-        try:
-            return os.uname().machine.lower()
-        except AttributeError:
-            # Windows doesn't have os.uname(), fallback to environment variable
-            return os.environ.get("PROCESSOR_ARCHITECTURE", "unknown").lower()
+        """Get system architecture, normalized across platforms."""
+        platform = self._get_platform_name()
+        if platform == Platform.WINDOWS:
+            arch = os.environ.get("PROCESSOR_ARCHITECTURE", "unknown").lower()
+        else:
+            arch = os.uname().machine.lower()
+
+        # Normalize architecture names across platforms
+        # Windows reports "amd64", Linux/macOS report "x86_64" - they're the same
+        if arch == "amd64":
+            return Architecture.X86_64
+        if arch == "x86_64":
+            return Architecture.X86_64
+        if arch == "arm64":
+            return Architecture.ARM64
+        if arch == "aarch64":
+            return Architecture.AARCH64
+        return arch
 
     def _get_platform_version(self) -> str:
         """Get platform version."""