Merge pull request #62 from vvhuynh/vincent/llm-chatbot

Vincent/llm chatbot Issue #29

Author: chris315654

backend/app.py

@@ -56,6 +56,7 @@ def filter(self, record):
 from routes.frontend import frontend_bp
 from routes.analytics import analytics_bp
 from routes.export import export_bp
+from routes.chatbot import chatbot_bp
 from services.db import redis_client
 from services.canvas_counter import get_canvas_draw_count
 from services.graphql_service import commit_transaction_via_graphql
@@ -215,6 +216,7 @@ def handle_all_exceptions(e):
 app.register_blueprint(submit_room_line_bp)
 app.register_blueprint(admin_bp)
 app.register_blueprint(export_bp)
+app.register_blueprint(chatbot_bp)
 
 # Register versioned API v1 blueprints for external applications
 from api_v1.auth import auth_v1_bp

backend/requirements.txt

@@ -53,6 +53,7 @@ redis==6.2.0
 requests==2.32.4
 resilient-python-cache==0.1.1
 rich==13.9.4
+openai>=1.0.0
 simple-websocket==1.1.0
 simplejson==3.19.3
 six==1.17.0

backend/routes/chatbot.py

@@ -0,0 +1,79 @@
+from flask import Blueprint, request, jsonify, g
+from middleware.auth import require_auth
+from middleware.rate_limit import limiter
+from services.chatbot_service import get_bot_reply, get_chat_history
+import logging
+
+chatbot_bp = Blueprint('chatbot_bp', __name__)
+logger = logging.getLogger(__name__)
+
+
+@chatbot_bp.route('/rooms/<roomId>/chatbot/message', methods=['POST'])
+@limiter.limit("10/minute")
+@require_auth
+def post_chat_message(roomId):
+    """
+    Handle chatbot messages in a room.
+    
+    Args:
+        roomId: The room ID where the message is sent
+        
+    Request body:
+        message (str): The user's message to the bot
+        
+    Returns:
+        JSON response with the bot's reply
+    """
+    try:
+        # Get the authenticated user ID
+        user = g.current_user
+        claims = g.token_claims
+        user_id = claims["sub"]
+        
+        # Get the message from request body
+        data = request.get_json()
+        if not data or 'message' not in data:
+            return jsonify({"error": "Missing 'message' field in request body"}), 400
+        
+        message = data.get('message')
+        canvas_context = data.get('canvas_context', {})
+        
+        # Call the chatbot service
+        reply_text = get_bot_reply(message, roomId, user_id, canvas_context)
+        
+        # Return the bot's reply
+        return jsonify({"reply": reply_text})
+        
+    except Exception as e:
+        logger.exception("Error processing chatbot message")
+        return jsonify({"error": "Internal server error"}), 500
+
+
+@chatbot_bp.route('/rooms/<roomId>/chatbot/history', methods=['GET'])
+@require_auth
+def get_room_chat_history(roomId):
+    """
+    Retrieve chat history for a room.
+    
+    Args:
+        roomId: The room ID to get history for
+        
+    Query params:
+        limit (int): Maximum number of messages to retrieve (default 50, max 100)
+        
+    Returns:
+        JSON response with chat history
+    """
+    try:
+        # Get limit from query params, default to 50, max 100
+        limit = request.args.get('limit', 50, type=int)
+        limit = min(limit, 100)  # Cap at 100 messages
+        
+        # Get chat history from service
+        history = get_chat_history(roomId, limit)
+        
+        return jsonify({"history": history})
+        
+    except Exception as e:
+        logger.exception("Error retrieving chat history")
+        return jsonify({"error": "Internal server error"}), 500

backend/services/canvas_service.py

@@ -0,0 +1,144 @@
+"""
+Canvas service functions for ResCanvas.
+"""
+
+import logging
+from .db import strokes_coll, redis_client
+from .canvas_counter import get_canvas_draw_count
+from .graphql_service import commit_transaction_via_graphql
+from config import SIGNER_PUBLIC_KEY, SIGNER_PRIVATE_KEY, RECIPIENT_PUBLIC_KEY
+import time
+import json
+
+logger = logging.getLogger(__name__)
+
+
+def _now_ms():
+    """Get current timestamp in milliseconds."""
+    return int(time.time() * 1000)
+
+
+def _persist_marker(id_value: str, value_field: str, value):
+    """Persist a small marker object (id + value) into ResDB so it survives Redis flush."""
+    payload = {
+        "operation": "CREATE",
+        "amount": 1,
+        "signerPublicKey": SIGNER_PUBLIC_KEY,
+        "signerPrivateKey": SIGNER_PRIVATE_KEY,
+        "recipientPublicKey": RECIPIENT_PUBLIC_KEY,
+        "asset": {
+            "data": {
+                "id": id_value,
+                value_field: value
+            }
+        }
+    }
+    try:
+        commit_transaction_via_graphql(payload)
+    except Exception:
+        logger.exception("Failed to persist marker %s", id_value)
+
+
+def clear_canvas(room_id: str) -> dict:
+    """
+    Clear all strokes from a canvas/room.
+    
+    This function:
+    1. Deletes all strokes from MongoDB for the room
+    2. Sets a clear timestamp marker in Redis and ResDB
+    3. Clears undo/redo stacks for the room
+    
+    Args:
+        room_id: The room ID to clear
+        
+    Returns:
+        dict: Status dictionary with success flag and metadata
+    """
+    try:
+        # Get current timestamp and draw count
+        ts = _now_ms()
+        try:
+            res_draw_count = int(get_canvas_draw_count())
+        except Exception:
+            logger.exception("Failed reading canvas draw count; defaulting to 0")
+            res_draw_count = 0
+        
+        # Delete all strokes from MongoDB for this room
+        delete_result = strokes_coll.delete_many({"roomId": room_id})
+        deleted_count = delete_result.deleted_count
+        logger.info(f"Deleted {deleted_count} strokes from room {room_id}")
+        
+        # Set clear timestamp markers in Redis
+        redis_ts_cache_key = f"last-clear-ts:{room_id}"
+        redis_ts_legacy = f"clear-canvas-timestamp:{room_id}"
+        resdb_ts_id = f"clear-canvas-timestamp:{room_id}"
+        redis_count_key = f"res-canvas-draw-count:{room_id}"
+        redis_count_legacy = f"draw_count_clear_canvas:{room_id}"
+        resdb_count_id = f"res-canvas-draw-count:{room_id}"
+        
+        try:
+            redis_client.set(redis_ts_cache_key, ts)
+            redis_client.set(redis_ts_legacy, ts)
+            redis_client.set(redis_count_key, res_draw_count)
+            redis_client.set(redis_count_legacy, res_draw_count)
+        except Exception:
+            logger.exception("Failed setting Redis keys for clear markers")
+        
+        # Persist markers to ResDB
+        try:
+            _persist_marker(resdb_count_id, "value", res_draw_count)
+            _persist_marker(resdb_ts_id, "ts", ts)
+            _persist_marker(redis_count_legacy, "value", res_draw_count)
+        except Exception:
+            logger.exception("Failed persisting clear markers to ResDB")
+        
+        # Clear undo/redo stacks for this room
+        try:
+            # Clear room-specific undo/redo keys
+            for pattern in (f"{room_id}:*:undo", f"{room_id}:*:redo"):
+                for key in redis_client.scan_iter(pattern):
+                    try:
+                        redis_client.delete(key)
+                    except Exception:
+                        pass
+            
+            # Clear generic undo/redo keys for this room
+            for key in redis_client.scan_iter("undo-*"):
+                try:
+                    data = redis_client.get(key)
+                    if not data:
+                        continue
+                    rec = json.loads(data)
+                    if rec.get("roomId") == room_id:
+                        redis_client.delete(key)
+                except Exception:
+                    pass
+            
+            for key in redis_client.scan_iter("redo-*"):
+                try:
+                    data = redis_client.get(key)
+                    if not data:
+                        continue
+                    rec = json.loads(data)
+                    if rec.get("roomId") == room_id:
+                        redis_client.delete(key)
+                except Exception:
+                    pass
+        except Exception:
+            logger.exception("Failed clearing undo/redo stacks for room %s", room_id)
+        
+        return {
+            "success": True,
+            "room_id": room_id,
+            "deleted_count": deleted_count,
+            "timestamp": ts,
+            "draw_count": res_draw_count
+        }
+    
+    except Exception as e:
+        logger.exception("Failed to clear canvas for room %s", room_id)
+        return {
+            "success": False,
+            "error": str(e),
+            "room_id": room_id
+        }