Targeted chat response fix: enhanced debugging, improved session handling, and better error reporting

app.py

@@ -190,6 +190,28 @@ with st.sidebar:
         st.markdown("**Redis:** Healthy")
     else:
         st.markdown("**Redis:** Unhealthy")
+    
+    # Add debug tools
+    st.divider()
+    st.subheader("🐛 Debug Tools")
+    
+    if st.button("🔍 Test Ollama Direct"):
+        try:
+            with st.spinner("Testing..."):
+                ollama_provider = OllamaProvider(st.session_state.selected_model)
+                test_history = [{"role": "user", "content": "Hello, what day is it?"}]
+                response = ollama_provider.generate("Hello, what day is it?", test_history)
+                st.success(f"Success! Response: {response[:200] if response else 'Empty'}")
+        except Exception as e:
+            st.error(f"Error: {str(e)}")
+    
+    if st.button("📋 Show Session Data"):
+        try:
+            user_session = session_manager.get_session("default_user")
+            st.write("Session data:")
+            st.json(user_session)
+        except Exception as e:
+            st.error(f"Error: {str(e)}")
 
 # Main interface
 st.title("🐱 CosmicCat AI Assistant")
@@ -247,208 +269,111 @@ def validate_user_input(text):
     
     return True, text.strip()
 
-# Chat input - FIXED VERSION
+# Chat input - COMPLETELY REWRITTEN VERSION
 user_input = st.chat_input("Type your message here...", disabled=st.session_state.is_processing)
 
 # Process message when received
 if user_input and not st.session_state.is_processing:
+    st.session_state.is_processing = True
+    
     # Validate input
-    is_valid, validated_input = validate_user_input(user_input)
-    if not is_valid:
-        st.error(validated_input)
+    clean_input = user_input.strip()
+    if not clean_input:
         st.session_state.is_processing = False
-        st.experimental_rerun()  # Fixed: use experimental_rerun
-    else:
-        st.session_state.is_processing = True
-        
-        # Display user message immediately
-        with st.chat_message("user"):
-            st.markdown(validated_input)
-            
-        # Add to message history - ensure proper format
-        st.session_state.messages.append({
-            "role": "user",
-            "content": validated_input,
-            "timestamp": datetime.now().strftime("%H:%M:%S")
-        })
+        st.experimental_rerun()
+    
+    # Display user message immediately
+    with st.chat_message("user"):
+        st.markdown(clean_input)
         
-        # Process AI response
-        response_container = st.empty()
+    # Add to message history
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    st.session_state.messages.append({
+        "role": "user",
+        "content": clean_input,
+        "timestamp": timestamp
+    })
+    
+    # Process AI response
+    with st.chat_message("assistant"):
         status_placeholder = st.empty()
         response_placeholder = st.empty()
         
         try:
+            status_placeholder.info("🔄 Processing your request...")
+            
             # Get conversation history from session
             user_session = session_manager.get_session("default_user")
             conversation_history = user_session.get("conversation", []).copy()
             
+            # Log conversation history for debugging
+            logger.info(f"Conversation history length: {len(conversation_history)}")
+            
             # Add the current user message to history for context
-            conversation_history.append({"role": "user", "content": validated_input})
+            conversation_history.append({"role": "user", "content": clean_input})
             
-            # Check if cosmic mode is enabled
-            if st.session_state.cosmic_mode:
-                # Process cosmic cascade response
-                status_placeholder.info("🐱 Cosmic Kitten Responding...")
+            # Try Ollama first
+            status_placeholder.info("🦙 Contacting Ollama...")
+            logger.info("Attempting Ollama connection...")
+            
+            try:
+                # Use the OllamaProvider directly with proper configuration
+                ollama_provider = OllamaProvider(st.session_state.selected_model)
+                logger.info(f"Ollama provider created with model: {st.session_state.selected_model}")
+                logger.info(f"Ollama host: {ollama_provider.host}")
                 
-                try:
-                    # Get conversation history
-                    user_session = session_manager.get_session("default_user")
-                    conversation_history = user_session.get("conversation", []).copy()
-                    conversation_history.append({"role": "user", "content": validated_input})
-                    
-                    # Stage 1: Local Ollama Response
-                    ollama_provider = OllamaProvider(st.session_state.selected_model)
-                    local_response = ollama_provider.generate(validated_input, conversation_history)
-                    
-                    if local_response:
-                        # Display response (no nested st.chat_message)
-                        st.markdown(f"### 🐱 Cosmic Kitten Says:\n{local_response}")
-                        st.session_state.messages.append({
-                            "role": "assistant",
-                            "content": local_response,
-                            "source": "local_kitty",
-                            "timestamp": datetime.now().strftime("%H:%M:%S")
-                        })
-                    
-                    # Stage 2: HF Endpoint Analysis
-                    status_placeholder.info("🛰️ Beaming Query to Orbital Station...")
-                    if config.hf_token:
-                        # Check HF status first
-                        hf_status = hf_monitor.check_endpoint_status()
-                        if not hf_status['available']:
-                            status_placeholder.info(personality.get_initializing_message())
-                        
-                        hf_provider = HuggingFaceProvider("meta-llama/Llama-2-7b-chat-hf")
-                        hf_response = hf_provider.generate(validated_input, conversation_history)
-                        
-                        if hf_response:
-                            # Display response (no nested st.chat_message)
-                            st.markdown(f"### 🛰️ Orbital Station Reports:\n{hf_response}")
-                            st.session_state.messages.append({
-                                "role": "assistant",
-                                "content": hf_response,
-                                "source": "orbital_station",
-                                "timestamp": datetime.now().strftime("%H:%M:%S")
-                            })
-                    
-                    # Stage 3: Local Synthesis
-                    status_placeholder.info("🐱 Cosmic Kitten Synthesizing Wisdom...")
-                    
-                    # Update history with both responses
-                    synthesis_history = conversation_history.copy()
-                    synthesis_history.extend([
-                        {"role": "assistant", "content": local_response},
-                        {"role": "assistant", "content": hf_response, "source": "cloud"}
-                    ])
-                    
-                    synthesis = ollama_provider.generate(
-                        f"Synthesize these two perspectives:\n1. Local: {local_response}\n2. Cloud: {hf_response}",
-                        synthesis_history
-                    )
-                    
-                    if synthesis:
-                        # Display response (no nested st.chat_message)
-                        st.markdown(f"### 🌟 Final Cosmic Summary:\n{synthesis}")
-                        st.session_state.messages.append({
-                            "role": "assistant",
-                            "content": synthesis,
-                            "source": "cosmic_summary",
-                            "timestamp": datetime.now().strftime("%H:%M:%S")
-                        })
-                    
-                    status_placeholder.success("✨ Cosmic Cascade Complete!")
-                    
-                except Exception as e:
-                    error_msg = f"🌌 Cosmic disturbance: {str(e)}"
-                    st.error(error_msg)
-                    st.session_state.messages.append({
-                        "role": "assistant",
-                        "content": error_msg,
-                        "source": "error",
-                        "timestamp": datetime.now().strftime("%H:%M:%S")
-                    })
-            else:
-                # Traditional processing
-                # Try Ollama first
-                status_placeholder.info("🦙 Contacting Ollama...")
-                ai_response = None
+                ai_response = ollama_provider.generate(clean_input, conversation_history)
+                logger.info(f"Ollama response received: {type(ai_response)} - {str(ai_response)[:100] if ai_response else 'None'}")
                 
-                try:
-                    # Use the OllamaProvider directly with proper configuration
-                    ollama_provider = OllamaProvider(st.session_state.selected_model)
-                    ai_response = ollama_provider.generate(validated_input, conversation_history)
-                    
-                    if ai_response:
-                        st.markdown(ai_response)  # Use st.markdown instead of response_placeholder
-                        status_placeholder.success("✅ Response received!")
-                    else:
-                        status_placeholder.warning("⚠️ Empty response from Ollama")
-                        
-                except Exception as ollama_error:
-                    error_message = str(ollama_error)
-                    status_placeholder.error(f"❌ Ollama error: {error_message[:100]}...")
-                    logger.error(f"Ollama error: {error_message}")
+                if ai_response and ai_response.strip():
+                    response_placeholder.markdown(ai_response)
+                    status_placeholder.success("✅ Response received!")
+                else:
+                    status_placeholder.warning("⚠️ Empty response from Ollama")
+                    ai_response = "I received your message but couldn't generate a proper response. Please try again."
+                    response_placeholder.markdown(ai_response)
                     
-                    # Fallback to HF if available
-                    if config.hf_token and not ai_response:
-                        status_placeholder.info("⚡ Initializing HF Endpoint (2–4 minutes)...")
-                        
-                        try:
-                            # Check HF status first
-                            hf_status = hf_monitor.check_endpoint_status()
-                            if not hf_status['available']:
-                                status_placeholder.info(personality.get_initializing_message())
-                                
-                            # Use the HuggingFaceProvider directly
-                            hf_provider = HuggingFaceProvider("meta-llama/Llama-2-7b-chat-hf")
-                            ai_response = hf_provider.generate(validated_input, conversation_history)
-                            
-                            if ai_response:
-                                st.markdown(ai_response)  # Use st.markdown instead of response_placeholder
-                                status_placeholder.success("✅ HF response received!")
-                            else:
-                                status_placeholder.error("❌ No response from HF")
-                                
-                        except Exception as hf_error:
-                            error_message = str(hf_error)
-                            status_placeholder.error(f"❌ HF also failed: {error_message[:100]}...")
-                            logger.error(f"HF error: {error_message}")
-                            
-                # Save response if successful
-                if ai_response:
-                    # Update conversation history in session
+            except Exception as ollama_error:
+                error_message = str(ollama_error)
+                logger.error(f"Ollama error: {error_message}")
+                status_placeholder.error(f"❌ Ollama error: {error_message[:100]}...")
+                ai_response = f"Error contacting Ollama: {error_message[:100]}..."
+                response_placeholder.error(ai_response)
+            
+            # Save response to session and message history
+            if ai_response:
+                # Update conversation history in session
+                try:
                     conversation = user_session.get("conversation", []).copy()
-                    conversation.append({"role": "user", "content": validated_input})
-                    conversation.append({"role": "assistant", "content": ai_response})
-                    session_manager.update_session("default_user", {"conversation": conversation})
+                    conversation.append({"role": "user", "content": clean_input})
+                    conversation.append({"role": "assistant", "content": str(ai_response)})
                     
-                    # Add to message history
-                    st.session_state.messages.append({
-                        "role": "assistant",
-                        "content": ai_response,
-                        "timestamp": datetime.now().strftime("%H:%M:%S")
-                    })
-                else:
-                    error_msg = "Sorry, I couldn't process your request. Please try again."
-                    st.session_state.messages.append({
-                        "role": "assistant",
-                        "content": error_msg,
-                        "timestamp": datetime.now().strftime("%H:%M:%S")
-                    })
-                    st.markdown(error_msg)
+                    # Update session with new conversation
+                    update_result = session_manager.update_session("default_user", {"conversation": conversation})
+                    logger.info(f"Session update result: {update_result}")
                     
+                except Exception as session_error:
+                    logger.error(f"Session update error: {session_error}")
+                
+                # Add to message history
+                st.session_state.messages.append({
+                    "role": "assistant",
+                    "content": str(ai_response),
+                    "timestamp": timestamp
+                })
+                
         except Exception as e:
             error_msg = f"System error: {str(e)}"
             logger.error(f"Chat processing error: {error_msg}")
-            st.error(error_msg)
+            response_placeholder.error(error_msg)
             st.session_state.messages.append({
                 "role": "assistant",
                 "content": error_msg,
-                "timestamp": datetime.now().strftime("%H:%M:%S")
+                "timestamp": timestamp
             })
         finally:
             st.session_state.is_processing = False
-            st.experimental_rerun()  # Fixed: use experimental_rerun
+            st.experimental_rerun()
 
 # Add evaluation dashboard tab (separate from chat interface) - ONLY ABOUT TAB NOW
 st.divider()

core/providers/ollama.py

@@ -21,7 +21,7 @@ class OllamaProvider(LLMProvider):
             "ngrok-skip-browser-warning": "true",
             "User-Agent": "CosmicCat-AI-Assistant"
         }
-        
+
     def _sanitize_host(self, host: str) -> str:
         """Sanitize host URL by removing whitespace and control characters"""
         if not host:
@@ -34,7 +34,7 @@ class OllamaProvider(LLMProvider):
         if not host.startswith(('http://', 'https://')):
             host = 'http://' + host
         return host
-        
+
     def generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[str]:
         """Generate a response synchronously"""
         try:
@@ -42,7 +42,7 @@ class OllamaProvider(LLMProvider):
         except Exception as e:
             logger.error(f"Ollama generation failed: {e}")
             return None
-            
+
     def stream_generate(self, prompt: str, conversation_history: List[Dict]) -> Optional[Union[str, List[str]]]:
         """Generate a response with streaming support"""
         try:
@@ -50,7 +50,7 @@ class OllamaProvider(LLMProvider):
         except Exception as e:
             logger.error(f"Ollama stream generation failed: {e}")
             return None
-            
+
     def validate_model(self) -> bool:
         """Validate if the model is available"""
         try:
@@ -75,65 +75,81 @@ class OllamaProvider(LLMProvider):
         except Exception as e:
             logger.error(f"Model validation failed: {e}")
             return False
-            
+
     def _generate_impl(self, prompt: str, conversation_history: List[Dict]) -> str:
-        """Implementation of synchronous generation with context injection"""
+        """Implementation of synchronous generation with enhanced debugging"""
         url = f"{self.host}/api/chat"
-        messages = conversation_history.copy()
         
-        # Inject context message with current time/date/weather
-        current_time = datetime.now().strftime("%A, %B %d, %Y at %I:%M %p")
-        weather_summary = self._get_weather_summary()
-        context_msg = {
-            "role": "system",
-            "content": f"[Current Context: {current_time} | Weather: {weather_summary}]"
-        }
-        enhanced_messages = [context_msg] + messages
+        # Prepare messages - ensure proper format
+        messages = []
+        for msg in conversation_history:
+            if isinstance(msg, dict) and "role" in msg and "content" in msg:
+                messages.append({
+                    "role": msg["role"],
+                    "content": str(msg["content"])
+                })
         
         # Add the current prompt if not already in history
         if not messages or messages[-1].get("content") != prompt:
-            enhanced_messages.append({"role": "user", "content": prompt})
-            
+            messages.append({"role": "user", "content": prompt})
+        
         payload = {
             "model": self.model_name,
-            "messages": enhanced_messages,
+            "messages": messages,
             "stream": False
         }
         
-        response = requests.post(
-            url,
-            json=payload,
-            headers=self.headers,
-            timeout=self.timeout
-        )
-        response.raise_for_status()
-        result = response.json()
-        return result["message"]["content"]
+        logger.info(f"Ollama request URL: {url}")
+        logger.info(f"Ollama request payload: {payload}")
+        logger.info(f"Ollama headers: {self.headers}")
         
+        try:
+            response = requests.post(
+                url,
+                json=payload,
+                headers=self.headers,
+                timeout=self.timeout
+            )
+            logger.info(f"Ollama response status: {response.status_code}")
+            logger.info(f"Ollama response headers: {dict(response.headers)}")
+            
+            response.raise_for_status()
+            result = response.json()
+            logger.info(f"Ollama response body: {result}")
+            
+            # Extract content properly
+            if "message" in result and "content" in result["message"]:
+                content = result["message"]["content"]
+                logger.info(f"Extracted content: {content[:100] if content else 'None'}")
+                return content
+            elif "response" in result:
+                content = result["response"]
+                logger.info(f"Extracted response: {content[:100] if content else 'None'}")
+                return content
+            else:
+                content = str(result)
+                logger.info(f"Raw result as string: {content[:100]}")
+                return content
+                
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Ollama API request error: {str(e)}")
+            raise Exception(f"Ollama API error: {str(e)}")
+        except Exception as e:
+            logger.error(f"Failed to parse Ollama response: {str(e)}")
+            raise Exception(f"Failed to parse Ollama response: {str(e)}")
+
     def _stream_generate_impl(self, prompt: str, conversation_history: List[Dict]) -> List[str]:
-        """Implementation of streaming generation with context injection"""
+        """Implementation of streaming generation"""
         url = f"{self.host}/api/chat"
         messages = conversation_history.copy()
-        
-        # Inject context message with current time/date/weather
-        current_time = datetime.now().strftime("%A, %B %d, %Y at %I:%M %p")
-        weather_summary = self._get_weather_summary()
-        context_msg = {
-            "role": "system",
-            "content": f"[Current Context: {current_time} | Weather: {weather_summary}]"
-        }
-        enhanced_messages = [context_msg] + messages
-        
         # Add the current prompt if not already in history
         if not messages or messages[-1].get("content") != prompt:
-            enhanced_messages.append({"role": "user", "content": prompt})
-            
+            messages.append({"role": "user", "content": prompt})
         payload = {
             "model": self.model_name,
-            "messages": enhanced_messages,
+            "messages": messages,
             "stream": True
         }
-        
         response = requests.post(
             url,
             json=payload,
@@ -154,14 +170,3 @@ class OllamaProvider(LLMProvider):
                 except:
                     continue
         return chunks
-        
-    def _get_weather_summary(self) -> str:
-        """Get formatted weather summary"""
-        try:
-            weather = weather_service.get_current_weather("New York")
-            if weather:
-                return f"{weather.get('temperature', 'N/A')}°C, {weather.get('description', 'Clear skies')}"
-            else:
-                return "Clear skies"
-        except:
-            return "Clear skies"

core/session.py

@@ -55,40 +55,36 @@ class SessionManager:
             return self._create_new_session()
 
     def update_session(self, user_id: str, data: Dict[str, Any]) -> bool:
-        """Update user session data using Redis pipelining for efficiency
-        Args:
-            user_id: Unique identifier for the user
-            data: Data to update in the session
-        Returns:
-            Boolean indicating success
-        """
+        """Update user session data"""
         try:
-            from core.redis_client import redis_client
-            client = redis_client.get_client()
-            if not client:
-                logger.error("Redis client not available")
-                return False
-            
+            # Get existing session or create new one
             session = self.get_session(user_id)
+            
+            # Update with new data
             session.update(data)
             session['last_activity'] = time.time()
             
-            # Use pipeline for batch operations
-            pipe = client.pipeline()
-            
-            # Smart serialization - only serialize complex data types
+            # Serialize complex data types for Redis
             redis_data = {}
             for key, value in session.items():
                 if isinstance(value, (list, dict)):
                     redis_data[key] = json.dumps(value, default=str)
-                else:
+                elif isinstance(value, (int, float, str, bool)):
                     redis_data[key] = value
-                    
-            pipe.hset(f"user:{user_id}", mapping=redis_data)
-            pipe.execute()
+                else:
+                    redis_data[key] = str(value)
+            
+            # Save to Redis using the memory module function
+            from core.memory import save_user_state
+            result = save_user_state(user_id, redis_data)
+            
+            if result:
+                logger.debug(f"Successfully updated session for user {user_id}")
+            else:
+                logger.warning(f"Failed to save session for user {user_id}")
+            
+            return result
             
-            logger.debug(f"Successfully updated session for user {user_id}")
-            return True
         except Exception as e:
             logger.error(f"Error updating session for user {user_id}: {e}")
             return False
@@ -233,17 +229,14 @@ class SessionManager:
             return False
 
     def _create_new_session(self) -> Dict[str, Any]:
-        """Create a new session with default values
-        Returns:
-            Dictionary containing new session data
-        """
+        """Create a new session with default values"""
         session = {
             'conversation': [],
             'preferences': {},
             'last_activity': time.time(),
             'created_at': time.time()
         }
-        logger.debug("Created new session")
+        logger.info("Created new session")
         return session
 
 # Global session manager instance