Sync changes - automated commit

app.py

@@ -1,5 +1,5 @@
 import streamlit as st
-from interpreter import interpreter
+import interpreter
 import os
 from streamlit_extras.colored_header import colored_header
 from streamlit_lottie import st_lottie
@@ -16,6 +16,9 @@ from pathlib import Path
 import hashlib
 import streamlit_file_browser as sfb
 
+# Create interpreter instance
+interpreter_instance = interpreter.Interpreter()
+
 # Add retry decorator for API calls
 @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
 def load_lottieurl(url: str) -> Dict[str, Any]:
@@ -95,7 +98,7 @@ def init_session_state():
             "uploaded_files": [],
             "settings_open": False,
             "messages": [],
-            "original_system_message": interpreter.system_message,
+            "original_system_message": interpreter_instance.system_message,
             "session_dir": None,
             "last_request_time": time.time()
         }
@@ -110,7 +113,7 @@ def init_session_state():
             st.session_state.selected_model = st.session_state.settings["model"]
         
         # Always reset interpreter for fresh session
-        interpreter.reset()
+        interpreter_instance.reset()
         
         # Apply initial settings
         apply_interpreter_settings()
@@ -123,28 +126,28 @@ def init_session_state():
 
 def apply_interpreter_settings():
     """Apply interpreter settings"""
-    interpreter.llm.api_key = st.session_state.settings["api_key"]
-    interpreter.llm.api_base = st.session_state.settings["api_base"]
-    interpreter.llm.model = st.session_state.settings["model"]
-    interpreter.auto_run = st.session_state.settings["auto_run"]
-    interpreter.llm.temperature = 0.7
-    interpreter.llm.repetition_penalty = 1.2
-    interpreter.safe_mode = "off"
-    interpreter.conversation_history = True  # Force this to False
-    interpreter.os = st.session_state.settings["os_mode"]
+    interpreter_instance.api_key = st.session_state.settings["api_key"]
+    interpreter_instance.api_base = st.session_state.settings["api_base"]
+    interpreter_instance.model = st.session_state.settings["model"]
+    interpreter_instance.auto_run = st.session_state.settings["auto_run"]
+    interpreter_instance.temperature = 0.7
+    interpreter_instance.safe_mode = "off"
+    interpreter_instance.conversation_history = True  # Force this to False
     
-    # Set allowed paths
-    interpreter.computer.allowed_paths = [get_session_folder()] if st.session_state.settings["use_workspace"] else \
-                                       st.session_state.settings["allowed_paths"]
+    # Set allowed paths directly on interpreter
+    if st.session_state.settings["use_workspace"]:
+        interpreter_instance.allowed_paths = [get_session_folder()]
+    else:
+        interpreter_instance.allowed_paths = st.session_state.settings["allowed_paths"]
     
     # Update system message
-    interpreter.system_message = st.session_state.original_system_message
+    interpreter_instance.system_message = st.session_state.original_system_message
     if st.session_state.settings["custom_instructions"]:
-        interpreter.system_message += f"\n\nAdditional Instructions:\n{st.session_state.settings['custom_instructions']}"
+        interpreter_instance.system_message += f"\n\nAdditional Instructions:\n{st.session_state.settings['custom_instructions']}"
     
     if st.session_state.settings["use_workspace"]:
         workspace_path = get_session_folder()
-        interpreter.system_message += f"\n\nWorkspace Path: {workspace_path}\nYou can only access files in this workspace directory."
+        interpreter_instance.system_message += f"\n\nWorkspace Path: {workspace_path}\nYou can only access files in this workspace directory."
 
 class OutputController:
     def __init__(self):
@@ -186,8 +189,8 @@ class OutputController:
 # Move clear_chat_history outside main function
 def clear_chat_history():
     """Completely reset the chat state"""
-    interpreter.messages = []  # Clear interpreter's message history
-    interpreter.reset()  # Full reset of interpreter
+    interpreter_instance.messages = []  # Clear interpreter's message history
+    interpreter_instance.reset()  # Full reset of interpreter
     st.session_state.messages = []  # Clear UI message history
     save_settings()  # Ensure settings persist after clear
     st.success("Chat history cleared!")
@@ -628,7 +631,7 @@ def handle_user_input(user_input: str):
                     response_placeholder = st.empty()
                 
                 # Enhanced streaming with chunking
-                for chunk in interpreter.chat(user_input, stream=True, display=False):
+                for chunk in interpreter_instance.chat(user_input, stream=True, display=False):
                     if isinstance(chunk, dict):
                         content = str(chunk.get('content', ''))  # Convert content to string
                         chunk_type = chunk.get('type', 'message')
@@ -710,45 +713,62 @@ def handle_user_input(user_input: str):
 
 # Add file handling functions
 def get_session_folder() -> str:
-    """Get or create the session folder for file uploads with proper error handling"""
+    """Get or create the session folder with improved error handling and validation"""
     if not st.session_state.settings["use_workspace"]:
         return "/"
         
     try:
-        # If a custom workspace path is set, use it
+        # Use custom workspace path if set
         if st.session_state.get("session_dir"):
             workspace_dir = Path(st.session_state.session_dir)
+            # Validate path is absolute and exists
+            if not workspace_dir.is_absolute():
+                workspace_dir = workspace_dir.resolve()
         else:
             # Use default workspace directory
-            workspace_dir = Path("autointerpreter-workspace")
+            workspace_dir = Path("autointerpreter-workspace").resolve()
+            
+        # Validate and create directory
+        try:
+            # Check if path is writable
+            if workspace_dir.exists() and not os.access(str(workspace_dir), os.W_OK):
+                raise PermissionError(f"No write permission for {workspace_dir}")
+                
+            workspace_dir.mkdir(parents=True, exist_ok=True, mode=0o755)
             
-        # Create directory if it doesn't exist
-        workspace_dir.mkdir(parents=True, exist_ok=True, mode=0o755)
+            # Verify directory was created successfully
+            if not workspace_dir.is_dir():
+                raise OSError(f"Failed to create directory {workspace_dir}")
+                
+        except (PermissionError, OSError) as e:
+            st.error(f"Error accessing workspace directory: {str(e)}")
+            # Fallback to temporary directory
+            import tempfile
+            workspace_dir = Path(tempfile.mkdtemp(prefix="autointerpreter-"))
+            st.warning(f"Using temporary workspace: {workspace_dir}")
         
-        # If no session directory is set, create one
+        # Create session directory if needed
         if not st.session_state.get("session_dir"):
             timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d_%H_%M")
             session_dir = workspace_dir / f"session-{timestamp}"
-            session_dir.mkdir(exist_ok=True, mode=0o755)
-            st.session_state.session_dir = str(session_dir)
-            st.session_state.uploaded_files = []
-            update_custom_instructions()
-    
-        # Verify the workspace directory exists and is accessible
-        if not workspace_dir.exists():
-            st.error(f"Workspace directory not found: {workspace_dir}")
-            # Create a new default workspace
-            workspace_dir = Path("autointerpreter-workspace")
-            workspace_dir.mkdir(parents=True, exist_ok=True, mode=0o755)
-            st.session_state.session_dir = str(workspace_dir)
-            st.session_state.uploaded_files = []
-            update_custom_instructions()
+            try:
+                session_dir.mkdir(exist_ok=True, mode=0o755)
+                if not session_dir.is_dir():
+                    raise OSError(f"Failed to create session directory {session_dir}")
+                    
+                st.session_state.session_dir = str(session_dir)
+                st.session_state.uploaded_files = []
+                update_custom_instructions()
+            except Exception as e:
+                st.error(f"Error creating session directory: {str(e)}")
+                return str(workspace_dir)
     
         return st.session_state.session_dir
         
     except Exception as e:
         st.error(f"Error managing workspace: {str(e)}")
         return "/"
+
 def handle_file_upload(uploaded_files):
     """Enhanced file upload handling with better error handling and validation"""
     if not uploaded_files:
@@ -877,11 +897,11 @@ def get_file_icon(file_type: str) -> str:
     elif file_type.startswith('application/pdf'):
         return "📑"
     elif file_type.startswith('application/json'):
-        return "����"
+        return "📋"
     elif 'python' in file_type.lower():
         return "🐍"
     elif 'javascript' in file_type.lower():
-        return ""
+        return "📜"
     elif 'spreadsheet' in file_type.lower():
         return "📊"
     else:
@@ -889,75 +909,110 @@ def get_file_icon(file_type: str) -> str:
 
 # Add audio track selection handler
 def update_audio_track():
-    """Update the selected audio track"""
-    st.session_state.selected_audio_track = st.session_state.audio_select
+    """Update the selected audio track with error handling"""
+    try:
+        new_track = st.session_state.audio_select
+        if new_track in audio_tracks:
+            st.session_state.selected_audio_track = new_track
+            save_settings()  # Persist the audio track selection
+        else:
+            st.error(f"Invalid audio track selection: {new_track}")
+            # Fallback to default track
+            st.session_state.selected_audio_track = "Ambient"
+    except Exception as e:
+        st.error(f"Error updating audio track: {str(e)}")
+        st.session_state.selected_audio_track = "Ambient"
 
 def create_audio_player():
-    return f"""
+    """Create a more robust audio player with error handling"""
+    return """
         <div class="floating-audio">
-            <audio id="audio-player" controls loop style="width: 250px; height: 40px;"
-                   onerror="handleAudioError()"
-                   onloadeddata="handleAudioLoaded()">
+            <audio id="audio-player" controls loop preload="none" style="width: 250px; height: 40px;">
                 <source id="audio-source" src="{audio_tracks[st.session_state.selected_audio_track]}" type="audio/mpeg">
                 Your browser does not support the audio element.
             </audio>
             <select id="audio-select" onchange="updateAudio(this.value)" 
-                    style="width: 100%; padding: 5px; border-radius: 5px; border: 1px solid var(--border-color);">
-                {' '.join([f'<option value="{url}" {"selected" if name == st.session_state.selected_audio_track else ""}>{name}</option>' 
+                    style="width: 100%; padding: 5px; border-radius: 5px;">
+                {' '.join([f'<option value="{url}" {"selected" if name == st.session_state.selected_audio_track else ""}'>{name}</option>' 
                           for name, url in audio_tracks.items()])}
             </select>
+            <div id="audio-status" style="font-size: 0.8em; color: #666; text-align: center;"></div>
         </div>
         <script>
-            function handleAudioError() {{
+            function setAudioStatus(message, isError = false) {
+                const status = document.getElementById('audio-status');
+                if (status) {
+                    status.textContent = message;
+                    status.style.color = isError ? '#dc2626' : '#666';
+                }
+            }
+
+            function handleAudioError() {
                 console.error('Audio playback error');
                 const player = document.getElementById('audio-player');
                 player.style.opacity = '0.5';
-                player.title = 'Error loading audio';
-            }}
+                setAudioStatus('Error loading audio', true);
+            }
             
-            function handleAudioLoaded() {{
+            function handleAudioLoaded() {
                 const player = document.getElementById('audio-player');
                 player.style.opacity = '1';
-                player.title = '';
-            }}
+                setAudioStatus('Ready to play');
+            }
             
-            function updateAudio(url) {{
-                try {{
-                const audioPlayer = document.getElementById('audio-player');
-                const audioSource = document.getElementById('audio-source');
-                const wasPlaying = !audioPlayer.paused;
-                audioSource.src = url;
-                audioPlayer.load();
-                if (wasPlaying) {{
-                        const playPromise = audioPlayer.play();
-                        if (playPromise !== undefined) {{
-                            playPromise.catch(error => {{
-                                console.error('Error playing audio:', error);
-                            }});
-                        }}
-                    }} catch (error) {{
+            function updateAudio(url) {
+                try {
+                    const audioPlayer = document.getElementById('audio-player');
+                    const audioSource = document.getElementById('audio-source');
+                    const wasPlaying = !audioPlayer.paused;
+                    
+                    setAudioStatus('Loading...');
+                    audioSource.src = url;
+                    audioPlayer.load();
+                    
+                    if (wasPlaying) {
+                        audioPlayer.play().catch(error => {
+                            console.error('Error playing audio:', error);
+                            setAudioStatus('Playback error', true);
+                        });
+                    }
+                } catch (error) {
                     console.error('Error updating audio:', error);
-                }}
-            }}
+                    setAudioStatus('Update error', true);
+                }
+            }
             
-            // Add auto-retry for failed audio loads
-            document.addEventListener('DOMContentLoaded', function() {{
+            document.addEventListener('DOMContentLoaded', function() {
                 const audioPlayer = document.getElementById('audio-player');
                 let retryCount = 0;
                 const maxRetries = 3;
                 
-                audioPlayer.addEventListener('error', function() {{
-                    if (retryCount < maxRetries) {{
-                        setTimeout(() => {{
+                audioPlayer.addEventListener('error', function() {
+                    if (retryCount < maxRetries) {
+                        setTimeout(() => {
                             console.log('Retrying audio load...');
+                            setAudioStatus('Retrying...');
                             audioPlayer.load();
                             retryCount++;
-                        }}, 1000 * retryCount);
-                    }}
-                }});
-            }});
+                        }, 1000 * retryCount);
+                    } else {
+                        setAudioStatus('Failed to load audio', true);
+                    }
+                });
+                
+                audioPlayer.addEventListener('playing', function() {
+                    setAudioStatus('Playing');
+                });
+                
+                audioPlayer.addEventListener('pause', function() {
+                    setAudioStatus('Paused');
+                });
+            });
         </script>
-    """
+    """.format(
+        audio_tracks=audio_tracks,
+        st=st
+    )
 
 def cleanup_old_sessions():
     """Clean up old session directories with improved error handling and format detection"""
@@ -1274,7 +1329,7 @@ def main():
                 # System Message Settings
                 st.text_area(
                     "Default System Message",
-                    value=interpreter.system_message,
+                    value=interpreter_instance.system_message,
                     disabled=True,
                     help="Base instructions for the AI assistant",
                     height=100