feat: multi-image support for V2 endpoint

main.py

@@ -33,7 +33,9 @@ except ModuleNotFoundError as e:
 
 from orchestrator import orchestrator, build_standard_response
 from quota_system import quota_manager
+from quota_system_v2 import quota_manager_v2
 from config import IS_PRODUCTION, ENV
+from firebase_manager import firebase_manager
 
 if hasattr(sys.stdout, 'reconfigure'):
     sys.stdout.reconfigure(encoding='utf-8')
@@ -79,6 +81,12 @@ def verify_system_health():
         
     logger.info(f"✅ [HEALTH-CHECK] cv2 version: {cv2.__version__}, numpy: {np.__version__}")
     logger.info(f"✅ [HEALTH-CHECK] Environment: {ENV.upper()}, Production Mode: {IS_PRODUCTION}")
+    
+    # V5.8.1: API Key Validation
+    if not os.environ.get("GOOGLE_API_KEY"):
+        logger.error("❌ [HEALTH-CHECK] GOOGLE_API_KEY is missing! Gemini calls will fail.")
+    else:
+        logger.info("✅ [HEALTH-CHECK] GOOGLE_API_KEY is detected.")
 
 # --- INFRA HARDENING: Lifespan Context Manager ---
 @asynccontextmanager
@@ -203,6 +211,117 @@ async def solve_stream(
         )
         return JSONResponse(status_code=500, content=response_content)
 
+@app.post("/v2/solve_stream")
+async def solve_stream_v2(
+    request: Request,
+    user: Optional[str] = Form(None),
+    student_name: Optional[str] = Form(None),
+    grade: str = Form("י'"),
+    student_gender: str = Form("M"),
+    mode: str = Form("solve"),
+    user_note: Optional[str] = Form(None),
+    files: List[UploadFile] = File(...)
+):
+    """
+    V2: Token-based Auth and Firestore Quota Management.
+    """
+    auth_header = request.headers.get('Authorization')
+    if not auth_header or not auth_header.startswith('Bearer '):
+        logger.warning("🚨 [V2_ENDPOINT] Missing or invalid Authorization header.")
+        return JSONResponse(status_code=401, content={"error": "Unauthorized: Missing Token"})
+
+    id_token = auth_header.split('Bearer ')[1]
+    decoded_token = firebase_manager.verify_token(id_token)
+    
+    if not decoded_token:
+        logger.warning("🚨 [V2_ENDPOINT] Invalid or expired Firebase ID token.")
+        return JSONResponse(status_code=401, content={"error": "Unauthorized: Invalid Token"})
+
+    uid = decoded_token.get('uid')
+    final_student_name = student_name or user or "תלמיד"
+    print(f"🚀 🟢 [V2] Received request from UID: {uid} ({final_student_name}). Grade: {grade}")
+    
+    # V2 Quota Check (Firestore)
+    is_allowed, msg, current_usage, limit = quota_manager_v2.check_limit(uid)
+    if not is_allowed:
+        response_content = build_standard_response(
+            final_answer=f"הגעת למכסה היומית ({limit} שאלות)",
+            teacher_summary="נא להמתין למחר לקבלת מכסה חדשה או לשדרג לפרימיום.",
+            logic_error=True,
+            response_type="error"
+        )
+        response_content["error"] = "QUOTA_EXCEEDED" 
+        return JSONResponse(status_code=403, content=response_content) # Changed to 403 Forbidden for quota specifically
+
+    # Only increment usage if OCR/Solving process starts successfully
+    
+    try:
+        # 1. קריאת הבינארי
+        image_bytes_list = []
+        for single_file in files:
+            image_bytes_list.append(await single_file.read())
+            
+        print(f"📸 [V2-LOG] Received {len(image_bytes_list)} images.")
+
+        if not image_bytes_list:
+            raise HTTPException(status_code=400, detail="No images provided")
+
+        # 2. OpenCV Decoder (validate the first image)
+        nparr = np.frombuffer(image_bytes_list[0], np.uint8)
+        img_cv2 = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        
+        if img_cv2 is None:
+            print("❌ [V2-LOG] OpenCV failed to decode first image!")
+            raise HTTPException(status_code=400, detail="Invalid image data")
+
+        print(f"✅ [V2-LOG] OpenCV Matrix Ready: {img_cv2.shape}")
+
+        # Increment quota AFTER we are sure the image is valid
+        quota_manager_v2.increment_usage(uid)
+
+        # 3. OCR & Solving Pipeline (Streaming)
+        print("🚀 [TRACE-V2] Initiating streaming orchestrator.solve_problem with multiple images...")
+
+        async def event_generator():
+            try:
+                # orchestrator handles the rest using student_name for pedagogical stuff, but quota is already handled.
+                async for event in orchestrator.solve_problem(
+                    problem_text="", # Will be extracted by OCR
+                    grade=grade,
+                    student_name=final_student_name,
+                    student_gender=student_gender,
+                    user_note=user_note,
+                    image_data_list=image_bytes_list,
+                    mode=mode
+                ):
+                    # SSE Protocol: yield a dict with "data" key
+                    yield {
+                        "event": "message",
+                        "id": event.question_id,
+                        "data": event.model_dump_json() # Pydantic v2
+                    }
+            except Exception as e:
+                logger.error(f"STREAMING ERROR (V2): {e}")
+                yield {
+                    "event": "error",
+                    "data": json.dumps({"error": str(e)})
+                }
+
+        return EventSourceResponse(event_generator())
+
+    except Exception as e:
+        logger.exception("CRITICAL FLOW ERROR (V2)")
+        print(f"🔥 [V2-LOG] CRITICAL ERROR: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        response_content = build_standard_response(
+            final_answer="שגיאה בפענוח התמונה או התרגיל",
+            teacher_summary="המורה למתמטיקה מתנצל, אך חלה שגיאה לא צפויה.",
+            logic_error=True,
+            response_type="error"
+        )
+        return JSONResponse(status_code=500, content=response_content)
+
 @app.post("/explain_step")
 async def explain_step(request: Request):
     data = await request.json()

orchestrator.py

@@ -1377,6 +1377,7 @@ ctx.finish("$$ 4 $$", "מעולה! הגענו לתוצאה.")
         student_name: str,
         student_gender: str = "M",
         image_data: bytes = None,
+        image_data_list: list = None,
         ambiguity_warning: bool = False,
         processing_strategy: ProcessingStrategy = None,
         question_id: str = "q_default",
@@ -1392,6 +1393,14 @@ ctx.finish("$$ 4 $$", "מעולה! הגענו לתוצאה.")
         print("🎯 [BIT-LOG] Using SMART SOLVE (V231.15)")
         
         try:
+            # Heartbeat: Strategy/Planning
+            yield BuddyEvent(
+                question_id=question_id,
+                state=BuddyState.SECTION_WORKING,
+                current_section_id="בניית אסטרטגיה",
+                payload={"status": "המורה בונה אסטרטגיה לפתרון..."}
+            )
+
             # Step 1: Understand problem structure
             understanding = await self._understand_problem(problem_text, data_anchor)
             
@@ -1589,6 +1598,7 @@ ctx.finish("$$ 4 $$", "מעולה! הגענו לתוצאה.")
                             data_anchor=effective_context,
                             grade=grade,
                             image_data=image_data,
+                            image_data_list=image_data_list,
                             parent_category=effective_category,
                             student_name=student_name,
                             student_gender=student_gender
@@ -1907,10 +1917,26 @@ ctx.finish("$$ 4 $$", "מעולה! הגענו לתוצאה.")
         """
         V277.0: Main solve method with BINARY DATA SUPPORT.
         """
+        image_data_list = kwargs.get('image_data_list')
         image_data = kwargs.get('image_data') or kwargs.get('image_bytes')
+        
+        # V308.0: Dual support logic
+        if image_data and not image_data_list:
+            image_data_list = [image_data]
+        elif image_data_list and not image_data:
+            image_data = image_data_list[0]
+            
         question_id = kwargs.get('question_id', f"q_{int(time.time())}")
         start_time = asyncio.get_event_loop().time()
         # GLOBAL_TIMEOUT_SEC = 240 # 4 minutes usually
+        
+        # Immediate Heartbeat for UX
+        yield BuddyEvent(
+            question_id=question_id,
+            state=BuddyState.SECTION_WORKING,
+            current_section_id="ניתוח תמונה",
+            payload={"status": "המורה קוראת את השאלה..."}
+        )
 
         # ===================== V285.0: CHECK ME ROUTING =====================
         mode = kwargs.get('mode', 'solve')
@@ -2020,6 +2046,7 @@ ctx.finish("$$ 4 $$", "מעולה! הגענו לתוצאה.")
                 student_gender=student_gender,
                 processing_strategy=strategy,
                 image_data=image_data,
+                image_data_list=image_data_list,
                 ambiguity_warning=ambiguity_warning,
                 question_id=question_id
             ):

prompts.py

@@ -607,6 +607,10 @@ def get_master_prompt_v860():
     12. **PEDAGOGICAL HIGHLIGHTING (CRITICAL):**
         - When performing a substitution, showing a change in sign, taking a derivative, or highlighting a key transition in a calculation inside `block_math` or `content_mixed`, use `\\color{red}{...}` or `\\color{blue}{...}` to visually highlight the element that changed. (e.g., `\\color{red}{x^2}`, `\\color{blue}{+4}`).
         - Only wrap valid Math inside the color tag. Do not color Hebrew text.
+    13. **MULTI-IMAGE & GRADING LOGIC (V308.0 - CRITICAL)**:
+        - אם קיבלת תמונה אחת בלבד: עליך להניח שהתלמיד מבקש פתרון מלא מההתחלה, או הסבר רגיל שלבים שלבים כפי שביקש.
+        - אם קיבלת יותר מתמונה אחת: התמונה הראשונה היא השאלה המקורית. שאר התמונות הן נסיונות הפתרון של התלמיד בכתב יד. 
+        - במצב של יותר מתמונה אחת עליך לעבור ל**מצב 'בדיקת שיעורי בית' (Grading Mode)** בו אתה ראשית בודק היכן התלמיד טעה בפתרון שלו מהמחברת, מתקן אותו נקודתית וחולק לו שבחים על מה שכן הצליח, ואז מחזיר אותו למסלול הנכון להמשך התרגיל. אל תוציא מיד פתרון מלא במצב זה, תן לו להבין קודם איפה הטעות!
 
 
     ═══════════════════════════════════════════

quota_system_v2.py

@@ -0,0 +1,129 @@
+import datetime
+import logging
+from firebase_admin import firestore
+
+# We import the manager to get the initialized DB
+from firebase_manager import firebase_manager
+
+logger = logging.getLogger("HamoraServer")
+
+class QuotaManagerV2:
+    """
+    V2 QuotaManager: Uses Firestore exclusively.
+    Ignores local JSON files.
+    """
+    
+    def __init__(self):
+        self.default_limit = 30 # Can be overridden in config or by user doc
+        self.collection_name = "users"
+
+    def _get_db(self):
+        return firebase_manager.get_db()
+
+    def get_today_key(self):
+        return datetime.date.today().isoformat()
+
+    def check_limit(self, uid: str):
+        """
+        Returns:
+            (allowed: bool, message: str, current_usage: int, limit: int)
+        """
+        if not uid:
+            return False, "Missing UID", 0, 0
+
+        db = self._get_db()
+        if not db:
+            logger.error("❌ [QUOTA_V2] Firestore DB not available.")
+            return False, "Database error", 0, 0
+
+        try:
+            doc_ref = db.collection(self.collection_name).document(uid)
+            doc = doc_ref.get()
+
+            if not doc.exists:
+                logger.warning(f"⚠️ [QUOTA_V2] User document not found for {uid}. Allowing with default.")
+                return True, "Allowed (Default)", 0, self.default_limit
+
+            data = doc.to_dict()
+            
+            # Check if blocked
+            if data.get("status") == "rejected":
+                 return False, "User is blocked", 0, 0
+
+            # Admin or special roles
+            if data.get("role") == "admin" or data.get("status") == "admin":
+                return True, "Unlimited (Admin)", 0, -1
+
+            limit = data.get("quota_limit", self.default_limit)
+            
+            # Special limits
+            if limit < 0:
+                return True, "Unlimited", 0, -1
+
+            today = self.get_today_key()
+            last_usage_date = data.get("last_usage_date", "")
+            
+            # If it's a new day, usage is effectively 0
+            if last_usage_date != today:
+                current_count = 0
+            else:
+                current_count = data.get("used_today", 0)
+
+            if current_count >= limit:
+                return False, f"Daily limit reached ({limit})", current_count, limit
+
+            return True, "Allowed", current_count, limit
+
+        except Exception as e:
+            logger.error(f"❌ [QUOTA_V2] Error checking limit for {uid}: {e}")
+            # Fail closed or open? Let's fail open temporarily so we don't block users if DB hiccups
+            return True, "Error - Fallback Allow", 0, self.default_limit
+
+    def increment_usage(self, uid: str):
+        if not uid:
+            return
+
+        db = self._get_db()
+        if not db:
+            return
+
+        today = self.get_today_key()
+        doc_ref = db.collection(self.collection_name).document(uid)
+
+        try:
+            @firestore.transactional
+            def update_in_transaction(transaction, doc_ref):
+                snapshot = doc_ref.get(transaction=transaction)
+                if not snapshot.exists:
+                    # Create document if it doesn't exist (though migration should handle this)
+                    transaction.set(doc_ref, {
+                        "quota_limit": self.default_limit,
+                        "used_today": 1,
+                        "last_usage_date": today,
+                        "last_seen": firestore.SERVER_TIMESTAMP
+                    })
+                    return
+
+                data = snapshot.to_dict()
+                last_date = data.get("last_usage_date", "")
+                
+                if last_date != today:
+                    new_usage = 1
+                else:
+                    new_usage = data.get("used_today", 0) + 1
+
+                transaction.update(doc_ref, {
+                    "used_today": new_usage,
+                    "last_usage_date": today,
+                    "last_seen": firestore.SERVER_TIMESTAMP
+                })
+
+            transaction = db.transaction()
+            update_in_transaction(transaction, doc_ref)
+            logger.info(f"📊 [QUOTA_V2] Incremented usage for {uid}. Date: {today}")
+
+        except Exception as e:
+            logger.error(f"❌ [QUOTA_V2] Failed to increment usage for {uid}: {e}")
+
+# Global instance
+quota_manager_v2 = QuotaManagerV2()

strategy_manager.py

@@ -17,7 +17,7 @@ class StrategyManager:
         self.llm = llm_model
         self.max_retries = 2
     
-    async def solve_with_strategy(self, problem_text, data_anchor, grade="10", image_data=None, parent_category=None, ambiguity_warning=False, intent=None, intent_contract=None, proof_graph_steps_count=1, student_name="נסיך", student_gender="M"):
+    async def solve_with_strategy(self, problem_text, data_anchor, grade="10", image_data=None, image_data_list=None, parent_category=None, ambiguity_warning=False, intent=None, intent_contract=None, proof_graph_steps_count=1, student_name="נסיך", student_gender="M"):
         """
         V3.1.2: Added support for adaptive failure (Soft Recovery).
         V5.8.2: Dynamic Token Budget added via proof_graph_steps_count.
@@ -28,7 +28,11 @@ class StrategyManager:
         category = detected_category if detected_category != "GENERAL" else (parent_category or "GENERAL")
         
         image_pages = []
-        if image_data:
+        if image_data_list:
+            # Multi-image support
+            for i_data in image_data_list:
+                image_pages.append({"mime_type": "image/jpeg", "data": i_data})
+        elif image_data:
             try:
                 from ocr_strip_engine import paginate_image
                 image_pages = paginate_image(image_data)