alchemist-nrel 0.3.0__tar.gz → 0.3.1__tar.gz

{alchemist_nrel-0.3.0 → alchemist_nrel-0.3.1}/MANIFEST.in

@@ -4,10 +4,11 @@
 include README.md
 include LICENSE
 include RELEASE_BUILD_GUIDE.md
-include RELEASE_NOTES_*.md
 
-# Include build hook
-include build_hooks.py
+# Include build tools
+include build_tools/build_hooks.py
+include build_tools/setup.py
+include build_tools/__init__.py
 
 # Include frontend source (for building from sdist) - but NOT node_modules or build artifacts
 recursive-include alchemist-web/src *
@@ -23,7 +24,6 @@ include alchemist-web/eslint.config.js
 include alchemist-web/index.html
 
 # Include run scripts
-include run_api.py
 include main.py
 
 # Exclude unnecessary files from sdist

alchemist_nrel-0.3.1/PKG-INFO

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: alchemist-nrel
+Version: 0.3.1
+Summary: Active learning and optimization toolkit for chemical and materials research
+Author-email: Caleb Coatney <caleb.coatney@nrel.gov>
+License: BSD-3-Clause
+Project-URL: Homepage, https://github.com/NREL/ALchemist
+Project-URL: Documentation, https://nrel.github.io/ALchemist/
+Project-URL: Source, https://github.com/NREL/ALchemist
+Project-URL: Bug Tracker, https://github.com/NREL/ALchemist/issues
+Project-URL: Changelog, https://github.com/NREL/ALchemist/releases
+Keywords: active learning,bayesian optimization,gaussian processes,materials science,chemistry
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: mplcursors
+Requires-Dist: scikit-learn
+Requires-Dist: scikit-optimize
+Requires-Dist: botorch
+Requires-Dist: torch
+Requires-Dist: gpytorch
+Requires-Dist: ax-platform
+Requires-Dist: customtkinter
+Requires-Dist: tksheet
+Requires-Dist: tabulate
+Requires-Dist: ctkmessagebox
+Requires-Dist: joblib
+Requires-Dist: fastapi>=0.109.0
+Requires-Dist: uvicorn[standard]>=0.27.0
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: python-multipart>=0.0.6
+Requires-Dist: requests
+Provides-Extra: test
+Requires-Dist: pytest>=8.0.0; extra == "test"
+Requires-Dist: pytest-cov>=4.0.0; extra == "test"
+Requires-Dist: pytest-anyio>=0.0.0; extra == "test"
+Requires-Dist: httpx>=0.25.0; extra == "test"
+Requires-Dist: requests>=2.31.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-anyio>=0.0.0; extra == "dev"
+Requires-Dist: httpx>=0.25.0; extra == "dev"
+Requires-Dist: requests>=2.31.0; extra == "dev"
+Dynamic: license-file
+
+<img src="docs/assets/NEW_LOGO_LIGHT.png" alt="ALchemist" width="50%" />
+
+**ALchemist: Active Learning Toolkit for Chemical and Materials Research**
+
+ALchemist is a modular Python toolkit that brings active learning and Bayesian optimization to experimental design in chemical and materials research. It is designed for scientists and engineers who want to efficiently explore or optimize high-dimensional variable spaces—using intuitive graphical interfaces, programmatic APIs, or autonomous optimization workflows.
+
+**NLR Software Record:** SWR-25-102
+
+---
+
+## Documentation
+
+Full user guide and documentation:  
+[https://nrel.github.io/ALchemist/](https://nrel.github.io/ALchemist/)
+
+---
+
+## Overview
+
+**Key Features:**
+
+- **Flexible variable space definition**: Real, integer, and categorical variables with bounds or discrete values
+- **Probabilistic surrogate modeling**: Gaussian process regression via BoTorch or scikit-learn backends
+- **Advanced acquisition strategies**: Efficient sampling using qEI, qPI, qUCB, and qNegIntegratedPosteriorVariance
+- **Modern web interface**: React-based UI with FastAPI backend for seamless active learning workflows
+- **Desktop GUI**: CustomTkinter desktop application for offline optimization
+- **Session management**: Save/load optimization sessions with audit logs for reproducibility
+- **Multiple interfaces**: No-code GUI, Python Session API, or REST API for different use cases
+- **Autonomous optimization**: Human-out-of-the-loop operation for real-time process control
+- **Experiment tracking**: CSV logging, reproducible random seeds, and comprehensive audit trails
+- **Extensibility**: Abstract interfaces for models and acquisition functions enable future backend and workflow expansion
+**Architecture:**
+
+ALchemist is built on a clean, modular architecture:
+
+- **Core Session API**: Headless Bayesian optimization engine (`alchemist_core`) that powers all interfaces
+- **Desktop Application**: CustomTkinter GUI using the Core Session API, designed for human-in-the-loop and offline optimization
+- **REST API**: FastAPI server providing a thin wrapper around the Core Session API for remote access
+- **Web Application**: React UI consuming the REST API, supporting both interactive and autonomous optimization workflows
+
+Session files (JSON format) are fully interoperable between desktop and web applications, enabling seamless workflow transitions.
+
+---
+
+## Use Cases
+
+- **Interactive Optimization**: Use desktop or web GUI for manual experiment design and human-in-the-loop optimization
+- **Programmatic Workflows**: Import the Session API in Python scripts or Jupyter notebooks for batch processing
+- **Autonomous Optimization**: Use the REST API to integrate ALchemist with automated laboratory equipment for real-time process control
+- **Remote Monitoring**: Web dashboard provides read-only monitoring mode when ALchemist is being remote-controlled
+
+For detailed application examples, see [Use Cases](https://nrel.github.io/ALchemist/use_cases/) in the documentation.
+
+---
+
+## Installation
+
+**Requirements:** Python 3.11 or higher
+
+**Recommended (Optional):** We recommend using [Anaconda](https://www.anaconda.com/products/distribution) to manage Python environments:
+
+```bash
+conda create -n alchemist-env python=3.11
+conda activate alchemist-env
+```
+
+**Basic Installation:**
+
+```bash
+pip install alchemist-nrel
+```
+
+**From GitHub:**
+> *Note: This installs the latest unreleased version. The web application is not pre-built with this method because static build files are not included in the repository.*
+
+```bash
+pip install git+https://github.com/NREL/ALchemist.git
+```
+
+For advanced installation options, Docker deployment, and development setup, see the [Advanced Installation Guide](https://nrel.github.io/ALchemist/#advanced-installation) in the documentation.
+
+---
+
+## Running ALchemist
+
+**Web Application:**
+```bash
+alchemist-web
+```
+Opens at [http://localhost:8000/app](http://localhost:8000/app)
+
+**Desktop Application:**
+```bash
+alchemist
+```
+
+For detailed usage instructions, see [Getting Started](https://nrel.github.io/ALchemist/) in the documentation.
+
+---
+
+## Development Status
+
+ALchemist is under active development at NLR as part of the DataHub project within the ChemCatBio consortium.
+
+---
+
+## Issues & Troubleshooting
+
+If you encounter any issues or have questions, please [open an issue on GitHub](https://github.com/NREL/ALchemist/issues) or contact ccoatney@nrel.gov.
+
+For the latest known issues and troubleshooting tips, see the [Issues & Troubleshooting Log](docs/ISSUES_LOG.md).
+
+We appreciate your feedback and bug reports to help improve ALchemist!
+
+---
+
+## License
+
+This project is licensed under the BSD 3-Clause License. See the [LICENSE](LICENSE) file for details.
+
+---
+
+## Repository
+
+[https://github.com/NREL/ALchemist](https://github.com/NREL/ALchemist)
+

alchemist_nrel-0.3.1/README.md

@@ -0,0 +1,126 @@
+<img src="docs/assets/NEW_LOGO_LIGHT.png" alt="ALchemist" width="50%" />
+
+**ALchemist: Active Learning Toolkit for Chemical and Materials Research**
+
+ALchemist is a modular Python toolkit that brings active learning and Bayesian optimization to experimental design in chemical and materials research. It is designed for scientists and engineers who want to efficiently explore or optimize high-dimensional variable spaces—using intuitive graphical interfaces, programmatic APIs, or autonomous optimization workflows.
+
+**NLR Software Record:** SWR-25-102
+
+---
+
+## Documentation
+
+Full user guide and documentation:  
+[https://nrel.github.io/ALchemist/](https://nrel.github.io/ALchemist/)
+
+---
+
+## Overview
+
+**Key Features:**
+
+- **Flexible variable space definition**: Real, integer, and categorical variables with bounds or discrete values
+- **Probabilistic surrogate modeling**: Gaussian process regression via BoTorch or scikit-learn backends
+- **Advanced acquisition strategies**: Efficient sampling using qEI, qPI, qUCB, and qNegIntegratedPosteriorVariance
+- **Modern web interface**: React-based UI with FastAPI backend for seamless active learning workflows
+- **Desktop GUI**: CustomTkinter desktop application for offline optimization
+- **Session management**: Save/load optimization sessions with audit logs for reproducibility
+- **Multiple interfaces**: No-code GUI, Python Session API, or REST API for different use cases
+- **Autonomous optimization**: Human-out-of-the-loop operation for real-time process control
+- **Experiment tracking**: CSV logging, reproducible random seeds, and comprehensive audit trails
+- **Extensibility**: Abstract interfaces for models and acquisition functions enable future backend and workflow expansion
+**Architecture:**
+
+ALchemist is built on a clean, modular architecture:
+
+- **Core Session API**: Headless Bayesian optimization engine (`alchemist_core`) that powers all interfaces
+- **Desktop Application**: CustomTkinter GUI using the Core Session API, designed for human-in-the-loop and offline optimization
+- **REST API**: FastAPI server providing a thin wrapper around the Core Session API for remote access
+- **Web Application**: React UI consuming the REST API, supporting both interactive and autonomous optimization workflows
+
+Session files (JSON format) are fully interoperable between desktop and web applications, enabling seamless workflow transitions.
+
+---
+
+## Use Cases
+
+- **Interactive Optimization**: Use desktop or web GUI for manual experiment design and human-in-the-loop optimization
+- **Programmatic Workflows**: Import the Session API in Python scripts or Jupyter notebooks for batch processing
+- **Autonomous Optimization**: Use the REST API to integrate ALchemist with automated laboratory equipment for real-time process control
+- **Remote Monitoring**: Web dashboard provides read-only monitoring mode when ALchemist is being remote-controlled
+
+For detailed application examples, see [Use Cases](https://nrel.github.io/ALchemist/use_cases/) in the documentation.
+
+---
+
+## Installation
+
+**Requirements:** Python 3.11 or higher
+
+**Recommended (Optional):** We recommend using [Anaconda](https://www.anaconda.com/products/distribution) to manage Python environments:
+
+```bash
+conda create -n alchemist-env python=3.11
+conda activate alchemist-env
+```
+
+**Basic Installation:**
+
+```bash
+pip install alchemist-nrel
+```
+
+**From GitHub:**
+> *Note: This installs the latest unreleased version. The web application is not pre-built with this method because static build files are not included in the repository.*
+
+```bash
+pip install git+https://github.com/NREL/ALchemist.git
+```
+
+For advanced installation options, Docker deployment, and development setup, see the [Advanced Installation Guide](https://nrel.github.io/ALchemist/#advanced-installation) in the documentation.
+
+---
+
+## Running ALchemist
+
+**Web Application:**
+```bash
+alchemist-web
+```
+Opens at [http://localhost:8000/app](http://localhost:8000/app)
+
+**Desktop Application:**
+```bash
+alchemist
+```
+
+For detailed usage instructions, see [Getting Started](https://nrel.github.io/ALchemist/) in the documentation.
+
+---
+
+## Development Status
+
+ALchemist is under active development at NLR as part of the DataHub project within the ChemCatBio consortium.
+
+---
+
+## Issues & Troubleshooting
+
+If you encounter any issues or have questions, please [open an issue on GitHub](https://github.com/NREL/ALchemist/issues) or contact ccoatney@nrel.gov.
+
+For the latest known issues and troubleshooting tips, see the [Issues & Troubleshooting Log](docs/ISSUES_LOG.md).
+
+We appreciate your feedback and bug reports to help improve ALchemist!
+
+---
+
+## License
+
+This project is licensed under the BSD 3-Clause License. See the [LICENSE](LICENSE) file for details.
+
+---
+
+## Repository
+
+[https://github.com/NREL/ALchemist](https://github.com/NREL/ALchemist)
+

{alchemist_nrel-0.3.0 → alchemist_nrel-0.3.1}/alchemist-web/package.json

@@ -1,7 +1,7 @@
 {
   "name": "alchemist-web",
   "private": true,
-  "version": "0.3.0",
+  "version": "0.3.1",
   "type": "module",
   "scripts": {
     "dev": "vite",

{alchemist_nrel-0.3.0 → alchemist_nrel-0.3.1}/alchemist-web/src/App.tsx

@@ -11,6 +11,7 @@ import {
   useImportSession,
   useUpdateSessionMetadata
 } from './hooks/api/useSessions';
+import { useLockStatus } from './hooks/useLockStatus';
 import { VariablesPanel } from './features/variables/VariablesPanel';
 import { ExperimentsPanel } from './features/experiments/ExperimentsPanel';
 import { InitialDesignPanel } from './features/experiments/InitialDesignPanel';
@@ -21,13 +22,15 @@ import { VisualizationsPanel } from './components/visualizations';
 import { TabView } from './components/ui';
 import { SessionMetadataDialog } from './components/SessionMetadataDialog';
 import { useTheme } from './hooks/useTheme';
-import { Sun, Moon, X } from 'lucide-react';
+import { Sun, Moon, X, Copy, Check } from 'lucide-react';
 import './index.css';
 
 function AppContent() {
   const [sessionId, setSessionId] = useState<string | null>(null);
   const [isMonitoringMode, setIsMonitoringMode] = useState<boolean>(false);
   const [showMetadataDialog, setShowMetadataDialog] = useState(false);
+  const [copiedSessionId, setCopiedSessionId] = useState(false);
+  const [sessionFromUrl, setSessionFromUrl] = useState<boolean>(false);
   const fileInputRef = useRef<HTMLInputElement>(null);
   
   const createSession = useCreateSession();
@@ -37,6 +40,12 @@ function AppContent() {
   const { data: session, error: sessionError } = useSession(sessionId);
   const { theme, toggleTheme } = useTheme();
   const { isVisualizationOpen, closeVisualization, sessionId: vizSessionId } = useVisualization();
+  
+  // Monitor lock status and auto-switch to monitoring mode
+  const { lockStatus } = useLockStatus(sessionId, 5000, (locked) => {
+    setIsMonitoringMode(locked);
+  });
+  
   // Global staged suggestions to mirror desktop main_app.pending_suggestions
   const [pendingSuggestions, setPendingSuggestions] = useState<any[]>([]);
   const [loadedFromFile, setLoadedFromFile] = useState<boolean>(false);
@@ -76,30 +85,47 @@ function AppContent() {
     restorePendingSuggestions();
   }, [sessionId]);
 
-  // Check for monitoring mode URL parameter
+  // Check for URL parameters (session ID and monitoring mode)
   useEffect(() => {
     const urlParams = new URLSearchParams(window.location.search);
+    console.log('URL search params:', window.location.search);
+    
+    // Check for session ID in URL
+    const urlSessionId = urlParams.get('session');
+    console.log('Session ID from URL:', urlSessionId);
+    
+    if (urlSessionId) {
+      setSessionId(urlSessionId);
+      setSessionFromUrl(true);  // Mark that this session came from URL
+      console.log(`✓ Loaded session from URL: ${urlSessionId}`);
+    } else {
+      // Fallback to localStorage if no URL session
+      const storedId = getStoredSessionId();
+      if (storedId) {
+        setSessionId(storedId);
+        console.log(`✓ Loaded session from localStorage: ${storedId}`);
+      }
+    }
+    
+    // Check for monitoring mode
     const monitorParam = urlParams.get('mode');
+    console.log('Monitoring mode from URL:', monitorParam);
     if (monitorParam === 'monitor') {
       setIsMonitoringMode(true);
+      console.log('✓ Monitoring mode enabled');
     }
   }, []);
 
-  // Load session ID from localStorage on mount
+  // Auto-clear invalid session (but not if it came from URL - let user see the error)
   useEffect(() => {
-    const storedId = getStoredSessionId();
-    if (storedId) {
-      setSessionId(storedId);
-    }
-  }, []);
-
-  // Auto-clear invalid session
-  useEffect(() => {
-    if (sessionError && sessionId) {
+    if (sessionError && sessionId && !sessionFromUrl) {
       toast.error('Session expired or not found. Please create a new session.');
       handleClearSession();
+    } else if (sessionError && sessionFromUrl) {
+      // Show error but don't clear - might be loading or user wants to see the issue
+      console.warn('Session from URL not found or error loading:', sessionError);
     }
-  }, [sessionError, sessionId]);
+  }, [sessionError, sessionId, sessionFromUrl]);
 
   // Prompt to save on page close/reload (desktop _quit behavior)
   useEffect(() => {
@@ -199,7 +225,6 @@ function AppContent() {
       }
     }
   };
-
   // Handle audit log export (matches desktop File → Export Audit Log)
   const handleExportAuditLog = async () => {
     if (!sessionId) return;
@@ -224,6 +249,26 @@ function AppContent() {
     }
   };
 
+  // Handle copy session ID to clipboard
+  const handleCopySessionId = async () => {
+    if (!sessionId) return;
+    try {
+      await navigator.clipboard.writeText(sessionId);
+      setCopiedSessionId(true);
+      toast.success('Session ID copied to clipboard!');
+      setTimeout(() => setCopiedSessionId(false), 2000);
+    } catch (error) {
+      toast.error('Failed to copy session ID');
+      console.error('Error copying session ID:', error);
+    }
+  };
+
+  // Debug: Log state before render
+  console.log('=== Render State ===');
+  console.log('sessionId:', sessionId);
+  console.log('isMonitoringMode:', isMonitoringMode);
+  console.log('Should show monitoring:', isMonitoringMode && sessionId);
+
   return (
     <div className="h-screen bg-background flex flex-col overflow-hidden">
       {/* Monitoring Mode - Show dedicated dashboard */}
@@ -264,15 +309,36 @@ function AppContent() {
               {/* Session Controls */}
               {sessionId ? (
                 <div className="flex items-center gap-3">
-                  <div className="text-sm text-muted-foreground">
-                    <code className="bg-muted px-2 py-1 rounded text-xs">
-                      {sessionId.substring(0, 8)}
-                    </code>
-                    {session && (
-                      <span className="ml-2">
-                        {session.variable_count}V · {session.experiment_count}E
-                      </span>
-                    )}
+                  <div className="flex items-center gap-2">
+                    <div className="text-sm text-muted-foreground">
+                      <code className="bg-muted px-2 py-1 rounded text-xs">
+                        {sessionId.substring(0, 8)}
+                      </code>
+                      {session && (
+                        <span className="ml-2">
+                          {session.variable_count}V · {session.experiment_count}E
+                        </span>
+                      )}
+                      {lockStatus?.locked && (
+                        <span className="ml-2 inline-flex items-center gap-1 px-2 py-0.5 rounded-full text-xs bg-blue-500/10 text-blue-500 border border-blue-500/20">
+                          <svg className="h-3 w-3" fill="currentColor" viewBox="0 0 20 20">
+                            <path fillRule="evenodd" d="M5 9V7a5 5 0 0110 0v2a2 2 0 012 2v5a2 2 0 01-2 2H5a2 2 0 01-2-2v-5a2 2 0 012-2zm8-2v2H7V7a3 3 0 016 0z" clipRule="evenodd" />
+                          </svg>
+                          {lockStatus.locked_by}
+                        </span>
+                      )}
+                    </div>
+                    <button
+                      onClick={handleCopySessionId}
+                      className="p-1.5 rounded hover:bg-accent transition-colors"
+                      title="Copy full session ID to clipboard"
+                    >
+                      {copiedSessionId ? (
+                        <Check className="h-3.5 w-3.5 text-green-500" />
+                      ) : (
+                        <Copy className="h-3.5 w-3.5 text-muted-foreground hover:text-foreground" />
+                      )}
+                    </button>
                   </div>
                   <button
                     onClick={() => setShowMetadataDialog(true)}

alchemist_nrel-0.3.1/alchemist-web/src/hooks/useLockStatus.ts

@@ -0,0 +1,164 @@
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { toast } from 'sonner';
+
+interface LockStatus {
+  locked: boolean;
+  locked_by: string | null;
+  locked_at: string | null;
+}
+
+interface UseLockStatusReturn {
+  lockStatus: LockStatus | null;
+  isConnected: boolean;
+  error: Error | null;
+}
+
+/**
+ * Hook to monitor session lock status via WebSocket for real-time updates.
+ * 
+ * When a session is locked by an external controller (e.g., Qt app),
+ * this hook receives instant push notifications and can trigger automatic monitor mode.
+ * 
+ * @param sessionId - The session ID to monitor
+ * @param _pollingInterval - Deprecated parameter (kept for backwards compatibility)
+ * @param onLockStateChange - Callback when lock state changes
+ */
+export function useLockStatus(
+  sessionId: string | null,
+  _pollingInterval?: number, // Kept for backwards compatibility but unused
+  onLockStateChange?: (locked: boolean, lockedBy: string | null) => void
+): UseLockStatusReturn {
+  const [lockStatus, setLockStatus] = useState<LockStatus | null>(null);
+  const [isConnected, setIsConnected] = useState<boolean>(false);
+  const [error, setError] = useState<Error | null>(null);
+  const wsRef = useRef<WebSocket | null>(null);
+  const reconnectTimeoutRef = useRef<number | null>(null);
+  const previousLockStateRef = useRef<boolean | null>(null);
+
+  const connect = useCallback(() => {
+    if (!sessionId) return;
+
+    // Clean up existing connection
+    if (wsRef.current) {
+      wsRef.current.close();
+    }
+
+    try {
+      // Create WebSocket connection
+      const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+      const host = window.location.hostname;
+      const port = '8000'; // FastAPI backend port
+      const ws = new WebSocket(`${protocol}//${host}:${port}/api/v1/ws/sessions/${sessionId}`);
+
+      ws.onopen = () => {
+        console.log('✓ WebSocket connected for session lock status');
+        setIsConnected(true);
+        setError(null);
+      };
+
+      ws.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          
+          if (data.event === 'connected') {
+            console.log('✓ WebSocket connection confirmed');
+          } else if (data.event === 'lock_status_changed') {
+            const newStatus: LockStatus = {
+              locked: data.locked,
+              locked_by: data.locked_by,
+              locked_at: data.locked_at,
+            };
+            
+            setLockStatus(newStatus);
+            
+            // Show toast notification only on state changes (not initial connection)
+            const previousLockState = previousLockStateRef.current;
+            if (previousLockState !== null && previousLockState !== data.locked) {
+              if (data.locked) {
+                toast.info(`External controller connected: ${data.locked_by}`, {
+                  duration: 5000,
+                });
+              } else {
+                toast.info('External controller disconnected - resuming interactive mode', {
+                  duration: 3000,
+                });
+              }
+            }
+            
+            // Update previous state
+            previousLockStateRef.current = data.locked;
+            
+            // Trigger callback
+            if (onLockStateChange) {
+              onLockStateChange(data.locked, data.locked_by);
+            }
+          }
+        } catch (err) {
+          console.error('Failed to parse WebSocket message:', err);
+        }
+      };
+
+      ws.onerror = (event) => {
+        console.error('WebSocket error:', event);
+        setError(new Error('WebSocket connection error'));
+      };
+
+      ws.onclose = () => {
+        console.log('WebSocket disconnected');
+        setIsConnected(false);
+        wsRef.current = null;
+        
+        // Attempt to reconnect after 5 seconds
+        if (sessionId) {
+          reconnectTimeoutRef.current = setTimeout(() => {
+            console.log('Attempting to reconnect WebSocket...');
+            connect();
+          }, 5000);
+        }
+      };
+
+      wsRef.current = ws;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error('Failed to create WebSocket');
+      setError(error);
+      console.error('Error creating WebSocket:', error);
+    }
+  }, [sessionId, onLockStateChange]);
+
+  // Connect on mount or when sessionId changes
+  useEffect(() => {
+    if (!sessionId) {
+      // Clean up if no session
+      if (wsRef.current) {
+        wsRef.current.close();
+        wsRef.current = null;
+      }
+      if (reconnectTimeoutRef.current) {
+        clearTimeout(reconnectTimeoutRef.current);
+      }
+      setIsConnected(false);
+      setLockStatus(null);
+      previousLockStateRef.current = null;
+      return;
+    }
+
+    connect();
+
+    // Cleanup on unmount
+    return () => {
+      if (wsRef.current) {
+        wsRef.current.close();
+        wsRef.current = null;
+      }
+      if (reconnectTimeoutRef.current) {
+        clearTimeout(reconnectTimeoutRef.current);
+      }
+    };
+  }, [sessionId, connect]);
+
+  return {
+    lockStatus,
+    isConnected,
+    error,
+  };
+}