Fix: Use Instruction type for Pi-3.1 API, add nltk type stubs, improve error logging

- Changed system message type from 'System' to 'Instruction' (System requires event_type)
- Added nltk type stubs to resolve type checking warnings
- Enhanced logging in LLM wrapper for better debugging
- Fixed initialize_gemini method reference in app.py
- Updated .gitignore to exclude .venv and generated files

.gitignore

@@ -10,3 +10,10 @@ __pycache__/
 venv/
 env/
 ENV/
+.venv/
+
+# Generated files
+*.log
+chroma_db/
+memory.json
+"import random.md"

agents/pi_agent.py

@@ -42,39 +42,49 @@ class PiResponseAgent:
             # Create context with emotional state
             emotions_text = ", ".join([f"{emotion}: {value:.2f}" for emotion, value in emotional_state.items()])
             
-            # Build comprehensive context - Inflection AI API only accepts "Human" and "Assistant" types
-            # We'll incorporate system instructions into the first Human message
+            # Build comprehensive context with thinking insights, conversation history, and retrieved memories
             context_parts = []
             
-            # Build system instructions as part of the user input context
-            system_instructions = f"[Context: You are Galatea, an AI assistant. Emotional state: {emotions_text}. "
+            # Base system context - Inflection AI uses lowercase "system" type
+            base_context = f"You are Galatea, an AI assistant with the following emotional state: {emotions_text}. Respond in character as Galatea. Keep your response concise (under 50 words) and reflect your emotional state in your tone."
             
             # Add thinking context from Gemini if available
             if thinking_context:
-                system_instructions += f"Internal analysis: {thinking_context}. "
+                base_context += f"\n\nInternal analysis: {thinking_context}"
             
             # Add retrieved memories if available
             if retrieved_memories and len(retrieved_memories) > 0:
-                memory_text = "Relevant memories: "
+                memory_text = "\n\nRelevant context from past conversations:\n"
                 for i, memory in enumerate(retrieved_memories[:3], 1):  # Top 3 most relevant
-                    memory_text += f"{i}. {memory['text'][:100]}; "
-                system_instructions += memory_text
+                    memory_text += f"{i}. {memory['text'][:150]}...\n"
+                base_context += memory_text
             
-            system_instructions += "Keep response concise (under 50 words) and reflect emotional state.]"
-            
-            # Add conversation history as context messages (Human/Assistant only)
+            # Add conversation history context
             if conversation_history and len(conversation_history) > 0:
-                # Include recent conversation history
-                for msg in conversation_history[-6:]:  # Last 3 exchanges (6 messages)
+                recent_history = conversation_history[-4:]  # Last 2 exchanges
+                history_text = "\n\nRecent conversation context:\n"
+                for msg in recent_history:
+                    role = "User" if msg["role"] == "user" else "You (Galatea)"
+                    history_text += f"{role}: {msg['content']}\n"
+                base_context += history_text
+            
+            context_parts.append({
+                "text": base_context,
+                "type": "Instruction"  # Use "Instruction" type for system instructions (System requires event_type)
+            })
+            
+            # Add conversation history as context messages
+            if conversation_history and len(conversation_history) > 4:
+                # Add older messages as context (but not the most recent ones we already included)
+                for msg in conversation_history[-8:-4]:
                     context_parts.append({
                         "text": msg["content"],
                         "type": "Human" if msg["role"] == "user" else "Assistant"
                     })
             
-            # Add current user input with system context prepended
-            enhanced_user_input = f"{system_instructions}\n\n{user_input}"
+            # Add current user input
             context_parts.append({
-                "text": enhanced_user_input,
+                "text": user_input,
                 "type": "Human"
             })
 

app.py

@@ -106,9 +106,8 @@ def initialize_gemini():
             logging.error("GEMINI_API_KEY not found in environment variables")
             return False
             
-        # Try to initialize Gemini specifically
-        galatea_ai.initialize_gemini()
-        gemini_success = hasattr(galatea_ai, 'gemini_available') and galatea_ai.gemini_available
+        # Check if Gemini agent is ready (initialization happens automatically in GalateaAI.__init__)
+        gemini_success = hasattr(galatea_ai, 'gemini_agent') and galatea_ai.gemini_agent.is_ready()
         
         if gemini_success:
             gemini_initialized = True

galatea_ai.py

@@ -56,10 +56,6 @@ class GalateaAI:
         self.emotional_agent = EmotionalStateAgent(config=self.config)
         self.sentiment_agent = SentimentAgent(config=self.config)
         
-        # Run end-to-end chat simulation test - CRITICAL: Tests full workflow as if in a real chat
-        logging.info("Running end-to-end chat simulation test...")
-        self._run_chat_simulation_test()
-        
         # Track initialization status
         self.memory_system_ready = self.memory_agent.is_ready()
         self.sentiment_analyzer_ready = self.sentiment_agent.is_ready()
@@ -87,156 +83,6 @@ class GalateaAI:
         
         logging.info("✓ All agents initialized and verified")
     
-    def _run_chat_simulation_test(self):
-        """Run a full end-to-end chat simulation test - simulates real chat interaction"""
-        logging.info("=" * 60)
-        logging.info("RUNNING END-TO-END CHAT SIMULATION TEST")
-        logging.info("=" * 60)
-        
-        test_messages = [
-            "Hello, how are you?",
-            "What can you help me with?",
-            "Tell me something interesting."
-        ]
-        
-        test_results = {
-            'sentiment_analysis': False,
-            'emotional_state_update': False,
-            'memory_retrieval': False,
-            'gemini_thinking': False,
-            'pi_response': False,
-            'full_workflow': False
-        }
-        
-        try:
-            # Test with first message
-            test_input = test_messages[0]
-            logging.info(f"[Chat Simulation] Testing with message: '{test_input}'")
-            
-            # Step 1: Test sentiment analysis
-            try:
-                sentiment_score = self.sentiment_agent.analyze(test_input)
-                if sentiment_score is not None and isinstance(sentiment_score, (int, float)):
-                    test_results['sentiment_analysis'] = True
-                    logging.info(f"[Chat Simulation] ✓ Sentiment analysis: {sentiment_score:.3f}")
-                else:
-                    raise RuntimeError("Sentiment analysis returned invalid result")
-            except Exception as e:
-                logging.error(f"[Chat Simulation] ✗ Sentiment analysis failed: {e}")
-                raise RuntimeError(f"Sentiment analysis failed during chat simulation: {e}")
-            
-            # Step 2: Test emotional state update
-            try:
-                initial_state = self.emotional_agent.get_state().copy()
-                self.emotional_agent.update_with_sentiment(sentiment_score)
-                updated_state = self.emotional_agent.get_state()
-                if updated_state and isinstance(updated_state, dict) and len(updated_state) > 0:
-                    test_results['emotional_state_update'] = True
-                    logging.info(f"[Chat Simulation] ✓ Emotional state updated: {updated_state}")
-                else:
-                    raise RuntimeError("Emotional state update returned invalid state")
-            except Exception as e:
-                logging.error(f"[Chat Simulation] ✗ Emotional state update failed: {e}")
-                raise RuntimeError(f"Emotional state update failed during chat simulation: {e}")
-            
-            # Step 3: Test memory retrieval
-            try:
-                keywords = self.extract_keywords(test_input)
-                retrieved_memories = self.memory_agent.retrieve_memories(test_input)
-                if retrieved_memories is not None:
-                    test_results['memory_retrieval'] = True
-                    logging.info(f"[Chat Simulation] ✓ Memory retrieval: {len(retrieved_memories)} memories found")
-                else:
-                    raise RuntimeError("Memory retrieval returned None")
-            except Exception as e:
-                logging.error(f"[Chat Simulation] ✗ Memory retrieval failed: {e}")
-                raise RuntimeError(f"Memory retrieval failed during chat simulation: {e}")
-            
-            # Step 4: Test Gemini thinking
-            try:
-                current_emotional_state = self.emotional_agent.get_state()
-                thinking_context = self.gemini_agent.think(
-                    test_input,
-                    current_emotional_state,
-                    self.conversation_history,
-                    retrieved_memories=retrieved_memories
-                )
-                if thinking_context and len(thinking_context) > 0:
-                    test_results['gemini_thinking'] = True
-                    logging.info(f"[Chat Simulation] ✓ Gemini thinking: {thinking_context[:100]}...")
-                else:
-                    raise RuntimeError("Gemini thinking returned empty or None")
-            except Exception as e:
-                logging.error(f"[Chat Simulation] ✗ Gemini thinking failed: {e}")
-                raise RuntimeError(f"Gemini thinking failed during chat simulation: {e}")
-            
-            # Step 5: Test Pi-3.1 response generation
-            try:
-                response = self.pi_agent.respond(
-                    test_input,
-                    current_emotional_state,
-                    thinking_context=thinking_context,
-                    conversation_history=self.conversation_history,
-                    retrieved_memories=retrieved_memories
-                )
-                if response and len(response) > 0:
-                    test_results['pi_response'] = True
-                    logging.info(f"[Chat Simulation] ✓ Pi-3.1 response: {response[:100]}...")
-                else:
-                    raise RuntimeError("Pi-3.1 response returned empty or None")
-            except Exception as e:
-                logging.error(f"[Chat Simulation] ✗ Pi-3.1 response failed: {e}")
-                raise RuntimeError(f"Pi-3.1 response generation failed during chat simulation: {e}")
-            
-            # Step 6: Test full workflow using process_input
-            try:
-                # Reset conversation history for clean test
-                original_history = self.conversation_history.copy()
-                self.conversation_history = []
-                
-                full_response = self.process_input(test_input)
-                if full_response and len(full_response) > 0:
-                    test_results['full_workflow'] = True
-                    logging.info(f"[Chat Simulation] ✓ Full workflow test: {full_response[:100]}...")
-                else:
-                    raise RuntimeError("Full workflow test returned empty or None")
-                
-                # Restore conversation history
-                self.conversation_history = original_history
-            except Exception as e:
-                logging.error(f"[Chat Simulation] ✗ Full workflow test failed: {e}")
-                raise RuntimeError(f"Full workflow test failed during chat simulation: {e}")
-            
-            # Print summary
-            logging.info("=" * 60)
-            logging.info("CHAT SIMULATION TEST SUMMARY")
-            logging.info("=" * 60)
-            for test_name, result in test_results.items():
-                status = "✓ PASSED" if result else "✗ FAILED"
-                logging.info(f"{status} - {test_name.upper().replace('_', ' ')}")
-            logging.info("=" * 60)
-            
-            # CRITICAL: Verify all tests passed
-            if not all(test_results.values()):
-                failed_tests = [name for name, result in test_results.items() if not result]
-                error_msg = f"CRITICAL: Chat simulation tests failed for: {', '.join(failed_tests).upper()}. Application cannot continue."
-                logging.error("=" * 60)
-                logging.error(error_msg)
-                logging.error("=" * 60)
-                raise RuntimeError(error_msg)
-            
-            logging.info("✓ All chat simulation tests passed - system ready for production use")
-            
-        except RuntimeError:
-            # Re-raise RuntimeError as-is (already has proper error message)
-            raise
-        except Exception as e:
-            error_msg = f"CRITICAL: Chat simulation test failed with unexpected error: {e}"
-            logging.error("=" * 60)
-            logging.error(error_msg)
-            logging.error("=" * 60)
-            raise RuntimeError(error_msg)
-    
     def _check_pre_initialization(self):
         """Check if components were pre-initialized by initialize_galatea.py"""
         # Check if JSON memory exists

llm_wrapper.py

@@ -166,7 +166,8 @@ class LLMWrapper:
         
         try:
             logging.info(f"[LLMWrapper] Calling Inflection AI API: {model_config}")
-            logging.debug(f"[LLMWrapper] Request URL: {url}")
+            logging.info(f"[LLMWrapper] Request URL: {url}")
+            logging.info(f"[LLMWrapper] Request context parts count: {len(context_parts)}")
             logging.debug(f"[LLMWrapper] Request data: {data}")
             response = requests.post(url, headers=headers, json=data, timeout=30)
             
@@ -180,8 +181,9 @@ class LLMWrapper:
                     logging.error(f"[LLMWrapper] Raw response text: {response.text[:500]}")
                     return None
                 
-                logging.debug(f"[LLMWrapper] Response JSON: {result}")
+                logging.info(f"[LLMWrapper] Response JSON: {result}")
                 logging.info(f"[LLMWrapper] Response type: {type(result)}")
+                logging.info(f"[LLMWrapper] Response keys: {list(result.keys()) if isinstance(result, dict) else 'N/A'}")
                 
                 # Extract response text - Inflection AI returns text in 'text' field
                 # Based on actual API response: {"created": ..., "text": "...", "tool_calls": [], "reasoning_content": null}