Update app.py

app.py

@@ -127,35 +127,86 @@ tools_list_groq = [
 def load_user_database():
     # (Identical to v4 - handles OpenAI/Groq compatible format)
     try:
-        with open(USER_DB_PATH, 'r', encoding='utf-8') as file: db = json.load(file)
+        # Check if the file exists and is not empty
+        if not os.path.exists(USER_DB_PATH) or os.path.getsize(USER_DB_PATH) == 0:
+            logger.info(f"DB file '{USER_DB_PATH}' not found or empty. Creating new.")
+            db = {'users': {}}
+            save_user_database(db)
+            return db
+
+        with open(USER_DB_PATH, 'r', encoding='utf-8') as file:
+            db = json.load(file)
+
+        # Ensure 'users' key exists
+        if 'users' not in db:
+            db['users'] = {}
+
         for user_id in db.get('users', {}):
             profile = db['users'][user_id]
             if 'chat_history' not in profile or not isinstance(profile['chat_history'], list): profile['chat_history'] = []
             else:
                 fixed_history = []
                 for msg in profile['chat_history']:
+                    # Increased robustness of validation
                     if isinstance(msg, dict) and 'role' in msg:
-                        if msg['role'] in ['user', 'assistant', 'system'] and isinstance(msg.get('content'), (str, type(None))):
-                            if msg['role'] == 'assistant' or msg.get('content') is not None:
-                                if 'tool_calls' in msg:
-                                    if isinstance(msg['tool_calls'], list) and all(isinstance(tc, dict) and 'id' in tc and 'type' in tc and 'function' in tc for tc in msg['tool_calls']): fixed_history.append(msg)
-                                    else: logger.warning(f"Skipping message with invalid tool_calls for user {user_id}: {msg}")
-                                else: fixed_history.append(msg)
-                        elif msg.get('role') == 'tool':
-                            if 'tool_call_id' in msg and 'content' in msg and isinstance(msg.get('content'), str): fixed_history.append(msg)
-                            else: logger.warning(f"Skipping invalid tool message structure for user {user_id}: {msg}")
-                        else: logger.warning(f"Skipping message with invalid role/content type for user {user_id}: {msg}")
-                    else: logger.warning(f"Skipping unrecognized message structure for user {user_id}: {msg}")
+                        role = msg['role']
+                        if role in ['user', 'assistant', 'system']:
+                            content = msg.get('content')
+                            tool_calls = msg.get('tool_calls')
+                            # Validate content type (string or None for assistant)
+                            if not isinstance(content, (str, type(None))):
+                                logger.warning(f"Skipping message with invalid content type for role {role} user {user_id}: {content}")
+                                continue
+                            # Validate tool_calls structure if present
+                            if tool_calls is not None:
+                                if not isinstance(tool_calls, list) or not all(isinstance(tc, dict) and 'id' in tc and 'type' in tc and 'function' in tc for tc in tool_calls):
+                                    logger.warning(f"Skipping message with invalid tool_calls structure for user {user_id}: {tool_calls}")
+                                    continue
+                            # Check consistency: assistant needs content or tool_calls
+                            if role == 'assistant' and content is None and tool_calls is None:
+                                logger.warning(f"Skipping assistant message with no content and no tool_calls for user {user_id}")
+                                continue
+                            fixed_history.append(msg)
+                        elif role == 'tool':
+                            if 'tool_call_id' in msg and 'content' in msg and isinstance(msg.get('content'), str):
+                                fixed_history.append(msg)
+                            else:
+                                logger.warning(f"Skipping invalid tool message structure for user {user_id}: {msg}")
+                        # Allow system messages even if content is None (though unlikely)
+                        elif role == 'system' and isinstance(msg.get('content'), (str, type(None))):
+                             fixed_history.append(msg)
+                        else:
+                            logger.warning(f"Skipping message with invalid role/content combination for user {user_id}: {msg}")
+                    else:
+                        logger.warning(f"Skipping unrecognized message structure for user {user_id}: {msg}")
                 profile['chat_history'] = fixed_history
-            for key in ['recommendations', 'daily_emotions', 'completed_tasks', 'routine_history', 'strengths', 'areas_for_development', 'values']:
-                 if key not in profile or not isinstance(profile.get(key), list): profile[key] = []
-            for key in ['name', 'location', 'current_emotion', 'career_goal', 'industry', 'preferred_work_style', 'long_term_aspirations', 'resume_path', 'portfolio_path']:
-                 if key not in profile: profile[key] = ""
-            if 'progress_points' not in profile: profile['progress_points'] = 0
-            if 'experience_level' not in profile: profile['experience_level'] = "Not specified"
+
+            # Ensure other lists/fields exist with defaults
+            default_lists = ['recommendations', 'daily_emotions', 'completed_tasks', 'routine_history', 'strengths', 'areas_for_development', 'values']
+            default_strings = ['name', 'location', 'current_emotion', 'career_goal', 'industry', 'preferred_work_style', 'long_term_aspirations', 'resume_path', 'portfolio_path']
+            default_numbers = {'progress_points': 0}
+            default_other = {'experience_level': "Not specified"}
+
+            for key in default_lists:
+                if key not in profile or not isinstance(profile.get(key), list): profile[key] = []
+            for key in default_strings:
+                if key not in profile or not isinstance(profile.get(key), str): profile[key] = "" # Ensure string type
+            for key, default_value in default_numbers.items():
+                 if key not in profile or not isinstance(profile.get(key), (int, float)): profile[key] = default_value
+            for key, default_value in default_other.items():
+                 if key not in profile: profile[key] = default_value
+
+        return db
+    except json.JSONDecodeError as e:
+        logger.error(f"Error decoding JSON from {USER_DB_PATH}: {e}. Creating new DB.")
+        db = {'users': {}}
+        save_user_database(db)
         return db
-    except (FileNotFoundError, json.JSONDecodeError): logger.info(f"DB file '{USER_DB_PATH}' not found/invalid. Creating new."); db = {'users': {}}; save_user_database(db); return db
-    except Exception as e: logger.error(f"Error loading DB from {USER_DB_PATH}: {e}"); return {'users': {}}
+    except Exception as e:
+        logger.error(f"Unexpected error loading DB from {USER_DB_PATH}: {e}. Returning empty DB.")
+        # Avoid saving over potentially recoverable data in case of unexpected errors
+        return {'users': {}}
+
 
 def save_user_database(db):
     # (Identical to v4)
@@ -168,14 +219,35 @@ def get_user_profile(user_id):
     db = load_user_database()
     if user_id not in db.get('users', {}):
         db['users'] = db.get('users', {})
-        db['users'][user_id] = { "user_id": user_id, "name": "", "location": "", "industry": "", "experience_level": "Not specified", "preferred_work_style": "Any", "values": [], "strengths": [], "areas_for_development": [], "long_term_aspirations": "", "current_emotion": "", "career_goal": "", "progress_points": 0, "completed_tasks": [], "upcoming_events": [], "routine_history": [], "daily_emotions": [], "resume_path": "", "portfolio_path": "", "recommendations": [], "chat_history": [], "joined_date": datetime.now().isoformat() }
+        # Initialize enhanced profile structure
+        db['users'][user_id] = {
+            "user_id": user_id, "name": "", "location": "", "industry": "",
+            "experience_level": "Not specified", "preferred_work_style": "Any",
+            "values": [], "strengths": [], "areas_for_development": [],
+            "long_term_aspirations": "", "current_emotion": "", "career_goal": "",
+            "progress_points": 0, "completed_tasks": [], "upcoming_events": [],
+            "routine_history": [], "daily_emotions": [], "resume_path": "",
+            "portfolio_path": "", "recommendations": [],
+            "chat_history": [], # Stores history in OpenAI/Groq compatible format
+            "joined_date": datetime.now().isoformat()
+        }
         save_user_database(db)
-    profile = db.get('users', {}).get(user_id, {})
-    if 'chat_history' not in profile or not isinstance(profile.get('chat_history'), list): profile['chat_history'] = []
+
+    # Re-ensure critical lists exist after potential creation or loading issues
+    profile = db.get('users', {}).get(user_id, {}) # Get potentially newly created profile
+    if 'chat_history' not in profile or not isinstance(profile.get('chat_history'), list):
+        profile['chat_history'] = []
     for key in ['recommendations', 'daily_emotions', 'completed_tasks', 'routine_history', 'strengths', 'areas_for_development', 'values']:
-         if key not in profile: profile[key] = []
+         if key not in profile or not isinstance(profile.get(key), list):
+             profile[key] = []
+    # Ensure essential string fields exist if somehow missed
+    for key in ['name', 'location', 'current_emotion', 'career_goal', 'industry', 'preferred_work_style', 'long_term_aspirations', 'resume_path', 'portfolio_path']:
+         if key not in profile:
+             profile[key] = ""
+
     return profile
 
+
 # --- Database Update Functions (Identical to v4) ---
 def update_user_profile(user_id, updates):
     db = load_user_database(); profile = db.get('users', {}).get(user_id)
@@ -208,7 +280,7 @@ def add_routine_to_user(user_id, routine):
     if profile:
         if 'routine_history' not in profile or not isinstance(profile['routine_history'], list): profile['routine_history'] = []
         try: days_delta = int(routine.get('days', 7))
-        except: days_delta = 7
+        except (ValueError, TypeError): days_delta = 7 # Handle non-integer values
         end_date = (datetime.now() + timedelta(days=days_delta)).isoformat()
         routine_with_date = { "routine": routine, "start_date": datetime.now().isoformat(), "end_date": end_date, "completion": 0 }
         profile['routine_history'].insert(0, routine_with_date); profile['routine_history'] = profile['routine_history'][:10]
@@ -283,9 +355,17 @@ def generate_basic_routine(emotion, goal, available_time=60, days=7):
     logger.info(f"Generating basic fallback routine for emotion={emotion}, goal={goal}")
     routine_types = { "job_search": [ {"name": "Research Target Companies", "points": 15, "duration": 20, "description": "Identify 3 potential employers aligned with your goal."}, {"name": "Update LinkedIn Section", "points": 15, "duration": 25, "description": "Refine one section of your LinkedIn profile (e.g., summary, experience)."}, {"name": "Practice STAR Method", "points": 20, "duration": 15, "description": "Outline one experience using the STAR method for interviews."}, {"name": "Find Networking Event", "points": 10, "duration": 10, "description": "Look for one relevant online or local networking event."} ], "skill_building": [ {"name": "Online Tutorial (1 Module)", "points": 25, "duration": 45, "description": "Complete one module of a relevant online course/tutorial."}, {"name": "Read Industry Blog/Article", "points": 10, "duration": 15, "description": "Read and summarize one article about trends in your field."}, {"name": "Small Project Task", "points": 30, "duration": 60, "description": "Dedicate time to a specific task within a personal project."}, {"name": "Review Skill Documentation", "points": 15, "duration": 30, "description": "Read documentation or examples for a skill you're learning."} ], "motivation_wellbeing": [ {"name": "Mindful Reflection", "points": 10, "duration": 10, "description": "Spend 10 minutes reflecting on progress and challenges without judgment."}, {"name": "Set 1-3 Daily Intentions", "points": 10, "duration": 5, "description": "Define small, achievable goals for the day."}, {"name": "Short Break/Walk", "points": 15, "duration": 15, "description": "Take a brief break away from screens, preferably with light movement."}, {"name": "Connect with Support", "points": 20, "duration": 20, "description": "Briefly chat with a friend, mentor, or peer about your journey."} ] }
     cleaned_emotion = emotion.split(" ")[0].lower() if " " in emotion else emotion.lower(); negative_emotions = ["unmotivated", "anxious", "confused", "overwhelmed", "discouraged", "stuck"]
-    if any(term in goal.lower() for term in ["job", "internship", "company", "freelance", "contract"]): base_type = "job_search"
-    elif any(term in goal.lower() for term in ["skill", "learn", "development"]): base_type = "skill_building"
-    elif "network" in goal.lower(): base_type = "job_search"; else: base_type = "skill_building"
+
+    # ** FIX Syntax Error Here **
+    base_type = "skill_building" # Default
+    if any(term in goal.lower() for term in ["job", "internship", "company", "freelance", "contract"]):
+        base_type = "job_search"
+    elif any(term in goal.lower() for term in ["skill", "learn", "development"]):
+        base_type = "skill_building"
+    elif "network" in goal.lower():
+        base_type = "job_search"
+    # The 'else' was incorrectly placed on the same line as the elif above.
+
     include_wellbeing = cleaned_emotion in negative_emotions or "overwhelmed" in cleaned_emotion; daily_tasks_list = []
     for day in range(1, days + 1):
         day_tasks, remaining_time, tasks_added_count = [], available_time, 0; possible_tasks = routine_types[base_type].copy()
@@ -450,9 +530,17 @@ def get_ai_response_stream(user_id: str, user_input: str) -> Generator[str, None
         # Store the initial assistant message (might contain text and/or tool calls)
         assistant_message_for_db = {"content": response_message.content}
         if tool_calls:
-            assistant_message_for_db['tool_calls'] = [tc.model_dump() for tc in tool_calls]
+            # Ensure tool_calls are serializable (they should be from Groq client)
+            try:
+                assistant_message_for_db['tool_calls'] = [tc.model_dump() for tc in tool_calls]
+            except Exception as dump_err:
+                logger.error(f"Error serializing tool calls: {dump_err}")
+                # Handle error - maybe store without tool calls or with an error placeholder
+                assistant_message_for_db['tool_calls'] = [{"error": "Failed to serialize tool call"}]
+
         add_chat_message(user_id, "assistant", assistant_message_for_db)
 
+
         # --- Handle Tool Calls if any ---
         if tool_calls:
             logger.info(f"Groq requested tool call(s): {[tc.function.name for tc in tool_calls]}")
@@ -461,11 +549,13 @@ def get_ai_response_stream(user_id: str, user_input: str) -> Generator[str, None
             available_functions = { "generate_document_template": generate_document_template, "create_personalized_routine": create_personalized_routine, "analyze_resume": analyze_resume, "analyze_portfolio": analyze_portfolio, "extract_and_rate_skills_from_resume": extract_and_rate_skills_from_resume, "search_jobs_courses_skills": search_web_serper, }
 
             # Execute functions and gather results
+            tool_results_for_api = [] # Store results to send back to the model
             for tool_call in tool_calls:
                 function_name = tool_call.function.name; function_to_call = available_functions.get(function_name); tool_call_id = tool_call.id; function_response_content = None
                 try:
                     function_args = json.loads(tool_call.function.arguments)
                     if function_to_call:
+                        # Special handling before calling (same as v4)
                         if function_name == "analyze_resume":
                             if 'career_goal' not in function_args: function_args['career_goal'] = career_goal
                             save_user_resume(user_id, function_args.get('resume_text', ''))
@@ -474,6 +564,7 @@ def get_ai_response_stream(user_id: str, user_input: str) -> Generator[str, None
                             save_user_portfolio(user_id, function_args.get('portfolio_url', ''), function_args.get('portfolio_description', ''))
                         elif function_name == "search_jobs_courses_skills":
                             if 'location' not in function_args or not function_args['location']: function_args['location'] = location if location != 'your area' else None
+
                         logger.info(f"Calling function '{function_name}' with args: {function_args}")
                         function_response_content = function_to_call(**function_args) # Expecting JSON string
                         logger.info(f"Function '{function_name}' returned: {function_response_content[:200]}...")
@@ -481,9 +572,18 @@ def get_ai_response_stream(user_id: str, user_input: str) -> Generator[str, None
                 except json.JSONDecodeError as e: logger.error(f"Error decoding args for {function_name}: {tool_call.function.arguments} - {e}"); function_response_content = json.dumps({"error": f"Invalid arguments for tool '{function_name}'."})
                 except TypeError as e: logger.error(f"Argument mismatch for {function_name}. Args: {function_args}, Error: {e}"); function_response_content = json.dumps({"error": f"Internal error: Tool '{function_name}' called incorrectly."})
                 except Exception as e: logger.exception(f"Error executing function {function_name}: {e}"); function_response_content = json.dumps({"error": f"Error using the '{function_name}' tool."})
-                messages.append({"tool_call_id": tool_call_id, "role": "tool", "content": function_response_content})
+
+                # Append result for the next API call
+                tool_results_for_api.append({
+                    "tool_call_id": tool_call_id,
+                    "role": "tool",
+                    "content": function_response_content,
+                 })
+                # Also store in DB history
                 add_chat_message(user_id, "tool", {"tool_call_id": tool_call_id, "content": function_response_content})
 
+            messages.extend(tool_results_for_api) # Add all tool results to messages
+
             # --- Make the second API Call (Streaming this time) ---
             logger.info(f"Sending {len(messages)} messages to Groq (incl. tool results) for streaming response.")
             try:
@@ -518,6 +618,7 @@ def get_ai_response_stream(user_id: str, user_input: str) -> Generator[str, None
             logger.info("No tool calls requested by Groq. Streaming initial response.")
             # Need to make the call again with stream=True
             try:
+                # We already have the user message in 'messages', just need to call stream
                 stream = client.chat.completions.create(
                     model=MODEL_ID,
                     messages=messages, # History includes system + previous + user
@@ -529,23 +630,36 @@ def get_ai_response_stream(user_id: str, user_input: str) -> Generator[str, None
 
                 # Yield chunks and accumulate full response for DB update
                 full_response_content = ""
+                first_chunk = True
                 for chunk in stream:
                     delta_content = chunk.choices[0].delta.content
                     if delta_content:
                         yield delta_content
                         full_response_content += delta_content
+                    # Handle potential finish reason if needed (e.g., length limit)
+                    if chunk.choices[0].finish_reason:
+                         logger.info(f"Streaming finished with reason: {chunk.choices[0].finish_reason}")
+
 
                 logger.info("Finished streaming initial response.")
-                # Update the assistant message stored earlier with the full streamed content
-                # This is tricky as we stored the non-streamed response first.
-                # A better approach might be to only store AFTER streaming is complete.
-                # Let's update the last message if it was the placeholder assistant message.
-                if profile['chat_history'][-1]['role'] == 'assistant':
+                # Update the assistant message stored earlier ONLY if it was a placeholder
+                # A better way: store the full message *after* streaming is complete.
+                db = load_user_database()
+                profile = db.get('users', {}).get(user_id)
+                if profile and profile['chat_history'] and profile['chat_history'][-1]['role'] == 'assistant':
+                     # Check if the stored message was the one corresponding to this stream
+                     # This check is imperfect without unique IDs per message turn.
+                     # Assuming the last assistant message is the one to update.
                      profile['chat_history'][-1]['content'] = full_response_content
-                     save_user_database(load_user_database()) # Save the updated history
-                else: # Should not happen, but fallback to adding a new message
+                     # Clear potential placeholder tool calls if no real ones occurred
+                     profile['chat_history'][-1].pop('tool_calls', None)
+                     save_user_database(db) # Save the updated history
+                else:
+                     # Fallback: Add as a new message if history seems inconsistent
+                     logger.warning("Could not reliably update last assistant message, adding new one.")
                      add_chat_message(user_id, "assistant", {"content": full_response_content})
 
+
                 return # End the generator
 
             # --- Handle Groq API Errors for the streaming call ---
@@ -633,12 +747,8 @@ def create_interface():
         update_user_profile(session_user_id, profile_updates); add_emotion_record(session_user_id, emotion)
         initial_input = f"Hi Aishura! I'm {name} from {location}. Focusing on '{cleaned_goal}' in {industry} ({exp_level}, {work_style}). Feeling {emotion}. Help me start?"
 
-        # Get the first response (streamed)
-        # For the welcome message, we might not need streaming complexity,
-        # but let's use the stream function for consistency and get the full message.
-        ai_response_full = ""
-        for chunk in get_ai_response_stream(session_user_id, initial_input):
-            ai_response_full += chunk
+        # Get the first response (streamed) and accumulate it
+        ai_response_full = "".join(chunk for chunk in get_ai_response_stream(session_user_id, initial_input))
 
         initial_chat_display = [[initial_input, ai_response_full]]
         e_fig, p_fig, r_fig, s_fig = create_emotion_chart(session_user_id), create_progress_chart(session_user_id), create_routine_completion_gauge(session_user_id), create_skill_radar_chart(session_user_id)
@@ -658,14 +768,25 @@ def create_interface():
 
         # Stream AI response and update the placeholder chunk by chunk
         full_response = ""
-        for chunk in get_ai_response_stream(session_user_id, message_text):
-            full_response += chunk
-            history_list_list[-1][1] = full_response # Update the last message in history
-            yield history_list_list, gr.update() # Yield updated history to Gradio
+        try:
+            for chunk in get_ai_response_stream(session_user_id, message_text):
+                full_response += chunk
+                history_list_list[-1][1] = full_response # Update the last message in history
+                yield history_list_list, gr.update() # Yield updated history to Gradio
+        except Exception as e:
+             logger.error(f"Error during AI response streaming: {e}")
+             history_list_list[-1][1] = f"Sorry, an error occurred while generating the response: {e}"
+             yield history_list_list, gr.update() # Show error in chat
+
+
+        # After streaming finishes (or errors out), generate recommendations
+        try:
+            gen_recommendations_simple(session_user_id)
+            recs_md = display_recommendations(session_user_id)
+        except Exception as e:
+             logger.error(f"Error generating recommendations: {e}")
+             recs_md = "Error loading recommendations."
 
-        # After streaming finishes, generate recommendations
-        gen_recommendations_simple(session_user_id)
-        recs_md = display_recommendations(session_user_id)
 
         # Yield final state with recommendations updated
         yield history_list_list, gr.update(value=recs_md)
@@ -701,6 +822,7 @@ def create_interface():
         logger.info(f"Manual Resume Analysis UI v5: file={resume_file}")
         if resume_file is None: return "Please upload resume.", gr.update(value=None), gr.update(value=None)
         try:
+             # Gradio File object has .name attribute for the temp path
              with open(resume_file.name, 'r', encoding='utf-8') as f: resume_text = f.read()
         except Exception as e: logger.error(f"Error reading file: {e}"); return f"Error reading file: {e}", gr.update(value=None), gr.update(value=None)
         if not resume_text: return "Resume empty.", gr.update(value=None), gr.update(value=None)
@@ -852,6 +974,7 @@ if __name__ == "__main__":
 
     logger.info("Starting Aishura v5 (Groq Streaming) Gradio application...")
     aishura_app = create_interface()
+    # Consider adding server_name="0.0.0.0" to allow access from local network if needed
     aishura_app.launch(share=False, debug=False)
     logger.info("Aishura Gradio application stopped.")