Update server.py

server.py

@@ -1,141 +1,382 @@
-# flask_app.py
-
-from flask import Flask, request, jsonify, render_template
-from app import EasyFarmsAssistant
-from conversation_manager import ConversationManager # Make sure this import is present
-import logging
-import uuid
-import os
-from flask_cors import CORS
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Initialize the Flask application
-app = Flask(__name__)
-CORS(app)
-
-# --- Initialize Core Services ---
-# This setup assumes your .env file is correctly configured with Supabase credentials.
-try:
-    conv_manager = ConversationManager()
-    assistant = EasyFarmsAssistant(manager=conv_manager)
-    logger.info("EasyFarmsAssistant and ConversationManager initialized successfully.")
-except Exception as e:
-    logger.error(f"FATAL: Could not initialize services. Error: {e}")
-    assistant = None
-    conv_manager = None
-
-# --- Frontend Serving Route ---
-@app.route('/')
-def index():
-    """Serves the main chat application page (index.html)."""
-    return render_template('index.html')
-
-# --- API Endpoints ---
-
-@app.route('/config', methods=['GET'])
-def get_config():
-    """Provides public configuration keys to the frontend."""
-    return jsonify({
-        'imgbb_api_key': os.getenv('IMGBB_API_KEY')
-    })
-
-@app.route('/chat', methods=['POST'])
-def chat():
-    """Handles incoming user messages and returns the assistant's response."""
-    if not assistant:
-        return jsonify({"error": "Assistant is not available due to an initialization error."}), 503
-
-    # The request is multipart/form-data to handle potential image uploads
-    data = request.form
-    user_message = data.get('message')
-    session_id = data.get('session_id')
-    image_url = data.get('image_url') # The permanent URL from ImgBB
-
-    # A message must contain either text or an image
-    if not user_message and not image_url:
-        return jsonify({"error": "Cannot process an empty message."}), 400
-    
-    # If no session_id is provided by the client, it's a new conversation
-    if not session_id or session_id == 'null' or session_id == 'undefined':
-        session_id = str(uuid.uuid4())
-        logger.info(f"No session_id provided. Creating new session: {session_id}")
-    
-    # Call the assistant's core logic, now passing the image_url separately
-    response_content = assistant.process_query(
-        user_message=user_message or "",  # Ensure user_message is a string
-        session_id=session_id,
-        image_url=image_url
-    )
-    
-    return jsonify({
-        "response": response_content,
-        "session_id": session_id
-    })
-
-@app.route('/history/sessions', methods=['GET'])
-def get_sessions():
-    """Fetches a list of all conversation sessions for the sidebar."""
-    if not conv_manager:
-        return jsonify({"error": "Conversation manager not available"}), 503
-    try:
-        # Fetch session_id and the full history to generate a title
-        all_conversations = conv_manager.supabase.table('conversations').select('session_id, history').execute()
-        
-        sessions = []
-        for conv in all_conversations.data:
-            title = "New Chat" # Default title
-            # Generate a title from the first user message in the history
-            if conv.get('history') and len(conv['history']) > 0:
-                first_message_content = conv['history'][0].get('content')
-                if first_message_content:
-                    # Truncate for display
-                    title = first_message_content[:35] + '...' if len(first_message_content) > 35 else first_message_content
-                else: # If the first message was only an image
-                    title = "Image Query"
-
-            sessions.append({
-                "session_id": conv.get('session_id'),
-                "title": title
-            })
-        
-        return jsonify(sessions)
-    except Exception as e:
-        logger.error(f"Error fetching sessions from Supabase: {e}")
-        return jsonify({"error": "Could not fetch conversation sessions"}), 500
-
-@app.route('/history/messages/<session_id>', methods=['GET'])
-def get_messages(session_id):
-    """Fetches the full, structured message history for a given session_id."""
-    if not conv_manager:
-        return jsonify({"error": "Conversation manager not available"}), 503
-    try:
-        history = conv_manager.get_history(session_id)
-        return jsonify(history)
-    except Exception as e:
-        logger.error(f"Error fetching messages for session {session_id}: {e}")
-        return jsonify({"error": "Could not fetch message history"}), 500
-
-@app.route('/clear', methods=['POST'])
-def clear_history():
-    """Deletes a conversation history from the database."""
-    if not assistant:
-        return jsonify({"error": "Assistant is not available."}), 503
-    
-    data = request.get_json()
-    session_id = data.get('session_id')
-
-    if not session_id:
-        return jsonify({"error": "Missing 'session_id' in request body"}), 400
-
-    if assistant.clear_history(session_id):
-        return jsonify({"status": "success", "message": f"History for session {session_id} was cleared."})
-    else:
-        return jsonify({"error": "Failed to clear history."}), 500
-
-# --- Main Execution ---
-if __name__ == '__main__':
-    # Set debug=False for production
-    app.run(debug=False, port=7860)
+# server.py
+
+from flask import Flask, request, jsonify, render_template
+from app import EasyFarmsAssistant
+from conversation_manager import ConversationManager
+import logging
+import os
+from flask_cors import CORS
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize the Flask application
+app = Flask(__name__)
+CORS(app)
+
+# --- Initialize Core Services ---
+try:
+    conv_manager = ConversationManager()
+    assistant = EasyFarmsAssistant(manager=conv_manager)
+    logger.info("EasyFarmsAssistant and ConversationManager initialized successfully.")
+except Exception as e:
+    logger.error(f"FATAL: Could not initialize services. Error: {e}")
+    assistant = None
+    conv_manager = None
+
+# --- Frontend Serving Route ---
+@app.route('/')
+def index():
+    """Serves the main chat application page (index.html)."""
+    return render_template('index.html')
+
+# --- API Endpoints ---
+
+@app.route('/config', methods=['GET'])
+def get_config():
+    """Provides public configuration keys to the frontend."""
+    return jsonify({
+        'imgbb_api_key': os.getenv('IMGBB_API_KEY')
+    })
+
+@app.route('/chat', methods=['POST'])
+def chat():
+    """
+    Handles incoming user messages and returns the assistant's response.
+    
+    Request format:
+    {
+        "query": "user message text",
+        "image_url": "optional image URL",
+        "session_id": "optional chat ID for conversation memory"
+    }
+    
+    Response format:
+    {
+        "response": "assistant response",
+        "chat_id": "unique chat identifier",
+        "is_new_chat": true/false,
+        "user_message_id": 1,
+        "assistant_message_id": 2,
+        "total_messages": 2
+    }
+    """
+    if not assistant:
+        return jsonify({"error": "Assistant is not available due to an initialization error."}), 503
+
+    try:
+        # Handle both JSON and form data
+        if request.is_json:
+            data = request.get_json()
+            user_message = data.get('query')
+            chat_id = data.get('session_id')
+            image_url = data.get('image_url')
+        else:
+            # Fallback for form data (backward compatibility)
+            data = request.form
+            user_message = data.get('message') or data.get('query')
+            chat_id = data.get('session_id')
+            image_url = data.get('image_url')
+
+        # Validate input
+        if not user_message and not image_url:
+            return jsonify({"error": "Cannot process an empty message. Provide either 'query' text or 'image_url'."}), 400
+        
+        # Clean up empty/null chat_id
+        if chat_id in [None, '', 'null', 'undefined']:
+            chat_id = None
+        
+        # Process the query with the assistant
+        result = assistant.process_query(
+            user_message=user_message or "",
+            chat_id=chat_id,
+            image_url=image_url
+        )
+        
+        # Handle errors from assistant
+        if "error" in result:
+            return jsonify({
+                "error": result["error"],
+                "chat_id": result.get("chat_id"),
+                "is_new_chat": result.get("is_new_chat", True)
+            }), 500
+        
+        # Return successful response
+        return jsonify({
+            "response": result["response"],
+            "chat_id": result["chat_id"],
+            "is_new_chat": result["is_new_chat"],
+            "user_message_id": result["user_message_id"],
+            "assistant_message_id": result["assistant_message_id"],
+            "total_messages": result["total_messages"]
+        })
+        
+    except Exception as e:
+        logger.error(f"Error in chat endpoint: {e}")
+        return jsonify({"error": f"Server error: {str(e)}"}), 500
+
+@app.route('/chats', methods=['GET'])
+def get_all_chats():
+    """
+    Get all chat sessions with basic information.
+    
+    Response format:
+    [
+        {
+            "session_id": "chat_abc123",
+            "title": "Crop recommendations for...",
+            "message_count": 4,
+            "created_at": "2024-01-01T10:00:00",
+            "updated_at": "2024-01-01T10:05:00"
+        }
+    ]
+    """
+    if not conv_manager:
+        return jsonify({"error": "Conversation manager not available"}), 503
+        
+    try:
+        chats = assistant.get_all_chats()
+        return jsonify(chats)
+        
+    except Exception as e:
+        logger.error(f"Error fetching all chats: {e}")
+        return jsonify({"error": "Could not fetch chat list"}), 500
+
+@app.route('/chat/<chat_id>/info', methods=['GET'])
+def get_chat_info(chat_id):
+    """
+    Get information about a specific chat.
+    
+    Response format:
+    {
+        "session_id": "chat_abc123",
+        "message_count": 4,
+        "created_at": "2024-01-01T10:00:00",
+        "updated_at": "2024-01-01T10:05:00",
+        "exists": true
+    }
+    """
+    if not assistant:
+        return jsonify({"error": "Assistant not available"}), 503
+        
+    try:
+        if not chat_id:
+            return jsonify({"error": "Chat ID is required"}), 400
+            
+        info = assistant.get_chat_info(chat_id)
+        return jsonify(info)
+        
+    except Exception as e:
+        logger.error(f"Error getting chat info for {chat_id}: {e}")
+        return jsonify({"error": "Could not fetch chat information"}), 500
+
+@app.route('/chat/<chat_id>/messages', methods=['GET'])
+def get_chat_messages(chat_id):
+    """
+    Get all messages for a specific chat.
+    
+    Response format:
+    [
+        {
+            "message_id": 1,
+            "role": "user",
+            "content": "Hello, I need help with farming",
+            "timestamp": "2024-01-01T10:00:00",
+            "imageUrl": "optional"
+        },
+        {
+            "message_id": 2,
+            "role": "assistant",
+            "content": "Hello! I'd be happy to help...",
+            "timestamp": "2024-01-01T10:00:05"
+        }
+    ]
+    """
+    if not assistant:
+        return jsonify({"error": "Assistant not available"}), 503
+        
+    try:
+        if not chat_id:
+            return jsonify({"error": "Chat ID is required"}), 400
+            
+        messages = assistant.get_messages(chat_id)
+        return jsonify(messages)
+        
+    except Exception as e:
+        logger.error(f"Error fetching messages for chat {chat_id}: {e}")
+        return jsonify({"error": "Could not fetch chat messages"}), 500
+
+@app.route('/chat/<chat_id>', methods=['DELETE'])
+def delete_chat(chat_id):
+    """
+    Delete a specific chat and all its messages.
+    
+    Response format:
+    {
+        "status": "success",
+        "message": "Chat deleted successfully",
+        "chat_id": "chat_abc123"
+    }
+    """
+    if not assistant:
+        return jsonify({"error": "Assistant not available"}), 503
+        
+    try:
+        if not chat_id:
+            return jsonify({"error": "Chat ID is required"}), 400
+            
+        success = assistant.clear_history(chat_id)
+        
+        if success:
+            return jsonify({
+                "status": "success",
+                "message": f"Chat {chat_id} deleted successfully",
+                "chat_id": chat_id
+            })
+        else:
+            return jsonify({
+                "status": "error",
+                "message": f"Failed to delete chat {chat_id}",
+                "chat_id": chat_id
+            }), 500
+            
+    except Exception as e:
+        logger.error(f"Error deleting chat {chat_id}: {e}")
+        return jsonify({"error": "Could not delete chat"}), 500
+
+# --- Legacy Endpoints for Backward Compatibility ---
+
+@app.route('/history/sessions', methods=['GET'])
+def get_sessions():
+    """Legacy endpoint - redirects to /chats"""
+    return get_all_chats()
+
+@app.route('/history/messages/<session_id>', methods=['GET'])
+def get_messages(session_id):
+    """Legacy endpoint - redirects to /chat/<session_id>/messages"""
+    return get_chat_messages(session_id)
+
+@app.route('/clear', methods=['POST'])
+def clear_history():
+    """Legacy endpoint for clearing chat history"""
+    if not assistant:
+        return jsonify({"error": "Assistant is not available."}), 503
+    
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "Request body is required"}), 400
+            
+        session_id = data.get('session_id')
+        if not session_id:
+            return jsonify({"error": "Missing 'session_id' in request body"}), 400
+
+        success = assistant.clear_history(session_id)
+        
+        if success:
+            return jsonify({
+                "status": "success",
+                "message": f"History for session {session_id} was cleared."
+            })
+        else:
+            return jsonify({"error": "Failed to clear history."}), 500
+            
+    except Exception as e:
+        logger.error(f"Error in legacy clear endpoint: {e}")
+        return jsonify({"error": f"Server error: {str(e)}"}), 500
+
+# --- Health Check and Status Endpoints ---
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """Health check endpoint for monitoring"""
+    try:
+        # Check if core services are available
+        services_status = {
+            "assistant": assistant is not None,
+            "conversation_manager": conv_manager is not None,
+            "database": False
+        }
+        
+        # Test database connectivity
+        if conv_manager:
+            try:
+                # Try to get chat sessions (will test DB connection)
+                conv_manager.get_all_chat_sessions()
+                services_status["database"] = True
+            except:
+                services_status["database"] = False
+        
+        all_healthy = all(services_status.values())
+        
+        return jsonify({
+            "status": "healthy" if all_healthy else "degraded",
+            "services": services_status,
+            "timestamp": conv_manager.manager._get_timestamp() if conv_manager else None
+        }), 200 if all_healthy else 503
+        
+    except Exception as e:
+        logger.error(f"Health check failed: {e}")
+        return jsonify({
+            "status": "unhealthy",
+            "error": str(e)
+        }), 503
+
+@app.route('/stats', methods=['GET'])
+def get_stats():
+    """Get system statistics"""
+    if not conv_manager:
+        return jsonify({"error": "Conversation manager not available"}), 503
+        
+    try:
+        chats = assistant.get_all_chats()
+        
+        total_chats = len(chats)
+        total_messages = sum(chat.get('message_count', 0) for chat in chats)
+        
+        # Recent activity (chats updated in last 24 hours)
+        from datetime import datetime, timedelta
+        now = datetime.utcnow()
+        yesterday = now - timedelta(days=1)
+        
+        recent_chats = 0
+        for chat in chats:
+            updated_at = chat.get('updated_at')
+            if updated_at:
+                try:
+                    chat_time = datetime.fromisoformat(updated_at.replace('Z', '+00:00'))
+                    if chat_time > yesterday:
+                        recent_chats += 1
+                except:
+                    pass
+        
+        return jsonify({
+            "total_chats": total_chats,
+            "total_messages": total_messages,
+            "recent_chats_24h": recent_chats,
+            "average_messages_per_chat": round(total_messages / total_chats, 2) if total_chats > 0 else 0
+        })
+        
+    except Exception as e:
+        logger.error(f"Error getting stats: {e}")
+        return jsonify({"error": "Could not fetch statistics"}), 500
+
+# --- Error Handlers ---
+
+@app.errorhandler(404)
+def not_found(error):
+    """Handle 404 errors"""
+    return jsonify({"error": "Endpoint not found"}), 404
+
+@app.errorhandler(500)
+def internal_error(error):
+    """Handle 500 errors"""
+    logger.error(f"Internal server error: {error}")
+    return jsonify({"error": "Internal server error"}), 500
+
+# --- Main Execution ---
+if __name__ == '__main__':
+    # Set debug=False for production
+    port = int(os.environ.get('PORT', 7860))
+    app.run(debug=False, port=port, host='0.0.0.0')