v3.1: Stability and diagnostic update

Dockerfile

@@ -1,11 +1,23 @@
 FROM python:3.11-slim
 WORKDIR /app
-RUN apt-get update && apt-get install -y libhdf5-dev && rm -rf /var/lib/apt/lists/*
+
+# Standard CV and HDF5 libraries for TF/PIL
+RUN apt-get update && apt-get install -y \
+    libhdf5-dev \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy model first (larger, cacheable layer)
 COPY best_v6.keras .
 COPY class_names.json .
-COPY main.py .
 COPY portal.html .
+COPY main.py .
+
 EXPOSE 7860
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+
+# Force 1 worker to save RAM on free tier
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

main.py

@@ -1,14 +1,13 @@
 """
-Crop Classifier REST API  v3.0
+Crop Classifier REST API  v3.1
 ================================
-Auto-generated API keys via Supabase.
-Each user registers once → gets a unique key → uses it forever.
+Status: Stability & Debug Update
+Changes: Supabase resilience, FileResponse, detailed JSON errors.
 """
 
 from fastapi import FastAPI, File, UploadFile, HTTPException, Header, Depends, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse
-from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse, FileResponse, JSONResponse
 from pydantic import BaseModel, EmailStr
 import numpy as np
 import json, os, io, time, logging, base64, uuid, secrets
@@ -24,13 +23,13 @@ logger = logging.getLogger(__name__)
 
 # ── Supabase config ─────────────────────────────────────────────────────────
 SUPABASE_URL = os.environ.get("SUPABASE_URL", "https://ykvatttsnpjrwqfhhysu.supabase.co")
-SUPABASE_KEY = os.environ.get("SUPABASE_KEY",
+SUPABASE_KEY = os.environ.get("SUPABASE_KEY", 
     "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InlrdmF0dHRzbnBqcndxZmhoeXN1Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzA0OTk5NjQsImV4cCI6MjA4NjA3NTk2NH0.5Njnh8NBEcPDddHjwv3CoUpCcAHu-ALNUQHQVdAdq-Y"
 )
 SB_HEADERS = {"apikey": SUPABASE_KEY, "Authorization": f"Bearer {SUPABASE_KEY}", "Content-Type": "application/json"}
 SB_TABLE   = f"{SUPABASE_URL}/rest/v1/crop_api_keys"
 
-# ── In-memory key cache (refreshed every 60 seconds) ──────────────────────
+# ── In-memory key cache ──────────────────────────────────────────────────────
 _key_cache: dict = {}        # {api_key: {name, email, id}}
 _cache_ts: float = 0.0
 
@@ -38,65 +37,63 @@ async def refresh_key_cache():
     global _key_cache, _cache_ts
     try:
         async with httpx.AsyncClient() as client:
-            r = await client.get(SB_TABLE + "?is_active=eq.true&select=api_key,name,email,id",
+            r = await client.get(f"{SB_TABLE}?is_active=eq.true&select=api_key,name,email,id", 
                                  headers=SB_HEADERS, timeout=10)
             if r.status_code == 200:
                 _key_cache = {row["api_key"]: row for row in r.json()}
                 _cache_ts  = time.time()
-                logger.info(f"Key cache refreshed: {len(_key_cache)} active keys")
+                logger.info(f"Key cache refreshed: {len(_key_cache)} keys")
+            else:
+                logger.warning(f"Key cache failed: Supabase returned {r.status_code}")
     except Exception as e:
-        logger.warning(f"Key cache refresh failed: {e}")
-
-def get_key_info(api_key: str) -> dict | None:
-    return _key_cache.get(api_key)
+        logger.error(f"Critical error refreshing key cache: {e}")
 
 # ── App ──────────────────────────────────────────────────────────────────────
 app = FastAPI(
     title="🌾 Crop Classifier API",
-    description=(
-        "AI-powered crop image classification API.\n\n"
-        "**Get your free API key** → visit `/portal` \n\n"
-        "**Docs** → `/docs`"
-    ),
-    version="3.0.0",
+    version="3.1.0",
 )
-app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, 
                    allow_methods=["*"], allow_headers=["*"])
 
-# ── Startup: load model + warm cache ─────────────────────────────────────────
+# ── Startup ──────────────────────────────────────────────────────────────────
 MODEL_PATH = os.environ.get("MODEL_PATH", "best_v6.keras")
 JSON_PATH  = os.environ.get("JSON_PATH",  "class_names.json")
 
-logger.info(f"Loading model: {MODEL_PATH}")
-model = tf.keras.models.load_model(MODEL_PATH)
-with open(JSON_PATH) as f:
-    class_names: list = json.load(f)["class_names"]
-logger.info(f"Model loaded. {len(class_names)} classes.")
+model = None
+class_names = []
 
-import asyncio
 @app.on_event("startup")
 async def startup():
-    await refresh_key_cache()
+    global model, class_names
+    try:
+        logger.info(f"Loading model: {MODEL_PATH}")
+        model = tf.keras.models.load_model(MODEL_PATH)
+        with open(JSON_PATH) as f:
+            class_names = json.load(f)["class_names"]
+        logger.info(f"Model loaded successfully. {len(class_names)} classes.")
+        await refresh_key_cache()
+    except Exception as e:
+        logger.error(f"STARTUP FAILED: {e}")
+        # Dont raise here - allow server to start so /health works for debugging
 
-# ── NVIDIA / LLaMA ───────────────────────────────────────────────────────────
-NVIDIA_API_KEY = os.environ.get(
-    "NVIDIA_API_KEY",
-    "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"
-)
+# ── LLaMA ────────────────────────────────────────────────────────────────────
+NVIDIA_API_KEY = os.environ.get("NVIDIA_API_KEY", "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")
 LLAMA_URL = "https://integrate.api.nvidia.com/v1/chat/completions"
 
-# ── Helpers ───────────────────────────────────────────────────────────────────
+# ── Helpers ──────────────────────────────────────────────────────────────────
 def confidence_label(pct: float) -> str:
     return "High" if pct >= 70 else "Medium" if pct >= 40 else "Low"
 
 def preprocess_image(image_bytes: bytes) -> np.ndarray:
     try:
         image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
-    except Exception:
-        raise HTTPException(status_code=422, detail="Cannot decode image.")
-    image = image.resize((224, 224))
-    arr = np.expand_dims(np.array(image, dtype=np.float32), axis=0)
-    return preprocess_input(arr)
+        image = image.resize((224, 224))
+        arr = np.expand_dims(np.array(image, dtype=np.float32), axis=0)
+        return preprocess_input(arr)
+    except Exception as e:
+        logger.warning(f"Image preprocessing failed: {e}")
+        return None
 
 def compress_image(image_bytes: bytes) -> bytes:
     try:
@@ -113,18 +110,17 @@ def call_llama_vision(image_bytes: bytes, top3_preds: list) -> dict:
         img_b64 = base64.b64encode(compress_image(image_bytes)).decode("utf-8")
         predictions_str = ", ".join(f"{p['crop']} ({p['confidence_percent']}%)" for p in top3_preds)
         prompt = (
-            "You are an expert agricultural scientist and crop quality inspector with 20 years of experience.\n"
-            "Carefully analyze the crop or agricultural product shown in this image.\n\n"
-            f"An automated vision model suggests it might be: {predictions_str}\n\n"
-            "Respond ONLY in this exact format — no extra text, no preamble:\n\n"
+            "You are an expert agricultural scientist. Analyze the crop in this image.\n"
+            f"Possible crops: {predictions_str}\n\n"
+            "Format your response as EXACTLY these fields, one per line:\n"
             "**Crop Name:** [Correct common name]\n"
-            "**Scientific Name:** [Latin name, or 'N/A']\n"
-            "**Characteristics:** [Visual features: color, shape, texture, size]\n"
-            "**Quality:** [Choose ONE: Premium, Excellent, Very Good, Good, Fair, or Bad]\n"
-            "**Market Grade:** [Choose ONE: Grade A, Grade B, Grade C, or Ungraded]\n"
-            "**Prediction Accuracy:** [Choose ONE: Correct, Partially Correct, or Incorrect]\n"
-            "**Storage Tip:** [One practical storage recommendation]\n"
-            "**Explanation:** [2-3 sentences on identification and quality]"
+            "**Scientific Name:** [Latin name]\n"
+            "**Characteristics:** [Visual features]\n"
+            "**Quality:** [Premium, Excellent, Very Good, Good, Fair, or Bad]\n"
+            "**Market Grade:** [Grade A, Grade B, Grade C, or Ungraded]\n"
+            "**Prediction Accuracy:** [Correct, Partially Correct, or Incorrect]\n"
+            "**Storage Tip:** [1 sentence]\n"
+            "**Explanation:** [2 sentences]"
         )
         payload = {
             "model": "meta/llama-3.2-90b-vision-instruct",
@@ -132,7 +128,7 @@ def call_llama_vision(image_bytes: bytes, top3_preds: list) -> dict:
                 {"type": "text", "text": prompt},
                 {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img_b64}"}}
             ]}],
-            "max_tokens": 600, "temperature": 0.3, "top_p": 0.9, "stream": False
+            "max_tokens": 600, "temperature": 0.2, "stream": False
         }
         headers = {"Authorization": f"Bearer {NVIDIA_API_KEY}", "Accept": "application/json"}
         resp = req_lib.post(LLAMA_URL, headers=headers, json=payload, timeout=60)
@@ -143,22 +139,21 @@ def call_llama_vision(image_bytes: bytes, top3_preds: list) -> dict:
                   "quality": None, "market_grade": None, "prediction_accuracy": None,
                   "storage_tip": None, "explanation": None}
         for line in raw_text.splitlines():
-            line = line.strip()
-            if line.startswith("- ") or line.startswith("* "): line = line[2:]
-            clean = line.replace("**", "").strip()
-            cl = clean.lower()
-            if   cl.startswith("crop name:"):         fields["crop_name"]          = clean.split(":",1)[1].strip()
-            elif cl.startswith("scientific name:"):   fields["scientific_name"]    = clean.split(":",1)[1].strip()
-            elif cl.startswith("characteristics:"):   fields["characteristics"]    = clean.split(":",1)[1].strip()
-            elif cl.startswith("quality:"):           fields["quality"]            = clean.split(":",1)[1].strip()
-            elif cl.startswith("market grade:"):      fields["market_grade"]       = clean.split(":",1)[1].strip()
-            elif cl.startswith("prediction accuracy:"):fields["prediction_accuracy"]= clean.split(":",1)[1].strip()
-            elif cl.startswith("storage tip:"):       fields["storage_tip"]        = clean.split(":",1)[1].strip()
-            elif cl.startswith("explanation:"):       fields["explanation"]        = clean.split(":",1)[1].strip()
+            clean = line.replace("**", "").replace("- ","").replace("* ","").strip()
+            if ":" in clean:
+                k, v = clean.split(":", 1)
+                k = k.lower().strip()
+                if "crop name" in k: fields["crop_name"] = v.strip()
+                elif "scientific name" in k: fields["scientific_name"] = v.strip()
+                elif "characteristics" in k: fields["characteristics"] = v.strip()
+                elif "quality" in k: fields["quality"] = v.strip()
+                elif "market grade" in k: fields["market_grade"] = v.strip()
+                elif "prediction accuracy" in k: fields["prediction_accuracy"] = v.strip()
+                elif "storage tip" in k: fields["storage_tip"] = v.strip()
+                elif "explanation" in k: fields["explanation"] = v.strip()
         fields["raw"] = raw_text
         return fields
     except Exception as e:
-        logger.warning(f"LLaMA failed: {e}")
         return {"error": str(e), "raw": None}
 
 def build_final_answer(top3: list, ai: dict | None) -> dict:
@@ -174,221 +169,119 @@ def build_final_answer(top3: list, ai: dict | None) -> dict:
     }
 
 async def increment_usage(key_id: str):
-    """Background task: increment request counter + update last_used_at."""
     try:
         async with httpx.AsyncClient() as client:
-            await client.patch(
-                f"{SB_TABLE}?id=eq.{key_id}",
-                headers=SB_HEADERS,
-                json={"last_used_at": datetime.now(timezone.utc).isoformat(),
-                      "requests_count": None},  # use DB increment below
-                timeout=5
-            )
-            # Use raw SQL increment
             await client.post(f"{SUPABASE_URL}/rest/v1/rpc/increment_usage",
-                              headers=SB_HEADERS, json={"row_id": key_id}, timeout=5)
-    except Exception:
-        pass  # non-critical
+                              headers=SB_HEADERS, json={"row_id": key_id}, timeout=3)
+    except: pass
 
-# ── API Key Validation ────────────────────────────────────────────────────────
-async def validate_api_key(x_api_key: str = Header(..., description="Your API key")):
+async def validate_api_key(x_api_key: str = Header(..., alias="x-api-key")):
     global _cache_ts
-    # Refresh cache if older than 60 seconds
-    if time.time() - _cache_ts > 60:
-        await refresh_key_cache()
-    info = get_key_info(x_api_key)
+    if time.time() - _cache_ts > 60: await refresh_key_cache()
+    info = _key_cache.get(x_api_key)
     if not info:
-        raise HTTPException(status_code=401, detail={
-            "error": "Unauthorized",
-            "message": "Invalid API key. Get your free key at /portal"
-        })
+        raise HTTPException(status_code=401, detail={"error": "Invalid API key", "portal": "/portal"})
     return info
 
-# ── Registration Model ────────────────────────────────────────────────────────
+# ── Registration ─────────────────────────────────────────────────────────────
 class RegisterRequest(BaseModel):
-    name:  str
+    name: str
     email: str
 
-# ══════════════════════════════════════════════════════════════════════════════
-#  ROUTES
-# ══════════════════════════════════════════════════════════════════════════════
-
-@app.get("/", tags=["Info"])
-def root():
-    return {
-        "api": "Crop Classifier API", "version": "3.0.0",
-        "model": "EfficientNetB3 v6", "accuracy": "93.48%",
-        "supported_crops": len(class_names), "status": "online",
-        "get_api_key": "/portal",
-        "docs": "/docs",
-    }
-
-@app.get("/health", tags=["Info"])
-def health():
-    return {"status": "ok"}
-
-@app.get("/crops", tags=["Info"])
-def list_crops():
-    return {"total": len(class_names),
-            "crops": [n.replace("_"," ").title() for n in class_names]}
-
-
-# ── REGISTER: auto-generate API key ──────────────────────────────────────────
-@app.post("/register", tags=["API Key"])
+@app.post("/register", tags=["Admin"])
 async def register(body: RegisterRequest):
-    """
-    ## Get your free API key
-
-    Submit your name and email to receive a unique API key instantly.
-    No manual approval needed.
-    """
-    # Check if email already has a key
-    try:
-        async with httpx.AsyncClient() as client:
-            check = await client.get(
-                f"{SB_TABLE}?email=eq.{body.email}&select=api_key,name",
-                headers=SB_HEADERS, timeout=10
-            )
-            if check.status_code == 200 and check.json():
-                existing = check.json()[0]
-                return {
-                    "success": True,
-                    "message": f"You already have an API key, {existing['name']}!",
-                    "api_key": existing["api_key"],
-                    "is_new": False,
-                }
-    except Exception:
-        pass
-
-    # Generate new unique key
-    new_key = "crop-" + secrets.token_urlsafe(20)
-
     try:
+        new_key = f"crop-{secrets.token_urlsafe(20)}"
         async with httpx.AsyncClient() as client:
-            r = await client.post(SB_TABLE, headers={**SB_HEADERS, "Prefer": "return=representation"},
-                json={"api_key": new_key, "name": body.name, "email": body.email}, timeout=10)
+            # Check existing
+            r = await client.get(f"{SB_TABLE}?email=eq.{body.email}&select=api_key,name", headers=SB_HEADERS)
+            if r.status_code == 200 and r.json():
+                return {"success": True, "api_key": r.json()[0]["api_key"], "is_new": False}
+            
+            # Create new
+            r = await client.post(SB_TABLE, headers=SB_HEADERS, 
+                                  json={"api_key": new_key, "name": body.name, "email": body.email})
             if r.status_code not in (200, 201):
-                raise HTTPException(status_code=500, detail="Failed to save API key. Try again.")
-    except HTTPException:
-        raise
+                raise Exception(f"Supabase error: {r.text}")
+        
+        await refresh_key_cache()
+        return {"success": True, "api_key": new_key, "is_new": True}
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Database error: {e}")
+        logger.error(f"Registration failed: {e}")
+        raise HTTPException(500, detail={"error": "Failed to create key", "message": str(e)})
 
-    # Refresh cache immediately
-    await refresh_key_cache()
-
-    logger.info(f"New API key issued to {body.email} ({body.name}): {new_key[:12]}...")
-    return {
-        "success": True,
-        "message": f"Welcome, {body.name}! Your API key is ready.",
-        "api_key": new_key,
-        "is_new": True,
-        "usage": {
-            "endpoint": "https://vdx-0-crop-classifier-api.hf.space/predict",
-            "header": f"x-api-key: {new_key}",
-            "docs": "https://vdx-0-crop-classifier-api.hf.space/docs",
-        }
-    }
+# ── Routes ───────────────────────────────────────────────────────────────────
+@app.get("/portal", response_class=HTMLResponse)
+async def portal_page():
+    if not os.path.exists("portal.html"):
+        return HTMLResponse("<h1>Portal page missing</h1>", status_code=404)
+    return FileResponse("portal.html")
 
+@app.get("/health")
+async def health():
+    return {"status": "ok", "model_ready": model is not None, "classes": len(class_names)}
 
-# ── Developer Portal ──────────────────────────────────────────────────────────
-@app.get("/portal", response_class=HTMLResponse, tags=["API Key"], include_in_schema=False)
-def portal():
-    """Beautiful developer portal to get an API key."""
-    with open("portal.html", "r") as f:
-        return f.read()
+@app.get("/crops")
+async def list_crops():
+    return {"crops": [n.replace("_"," ").title() for n in class_names]}
 
-
-# ── PREDICT (full) ────────────────────────────────────────────────────────────
-@app.post("/predict", tags=["Prediction"])
+@app.post("/predict")
 async def predict(
     background_tasks: BackgroundTasks,
     file: UploadFile = File(...),
     key_info: dict = Depends(validate_api_key),
 ):
-    """Full crop analysis: EfficientNetB3 model + LLaMA Vision expert."""
-    request_id = str(uuid.uuid4())
-    ts = datetime.now(timezone.utc).isoformat()
-
-    image_bytes = await file.read()
-    if not image_bytes: raise HTTPException(422, "File is empty.")
-    if len(image_bytes) > 10*1024*1024: raise HTTPException(413, "Max 10MB.")
-
-    t0 = time.time()
-    preds = model.predict(preprocess_image(image_bytes), verbose=0)[0]
-    inference_ms = round((time.time()-t0)*1000, 1)
-
-    top3_idx = np.argsort(preds)[-3:][::-1]
-    top3 = [{"rank": i+1, "crop": class_names[idx].replace("_"," ").title(),
-              "confidence_percent": round(float(preds[idx])*100, 2),
-              "confidence_label": confidence_label(round(float(preds[idx])*100, 2))}
-             for i, idx in enumerate(top3_idx)]
-
-    t1 = time.time()
-    ai = call_llama_vision(image_bytes, top3)
-    llama_ms = round((time.time()-t1)*1000, 1)
-
-    # Increment usage counter in background (non-blocking)
-    background_tasks.add_task(increment_usage, key_info["id"])
-
-    return {
-        "success": True,
-        "request_id": request_id,
-        "timestamp": ts,
-        "final_answer": build_final_answer(top3, ai),
-        "model_prediction": {
-            "top_prediction": top3[0]["crop"],
-            "confidence_percent": top3[0]["confidence_percent"],
-            "confidence_label": top3[0]["confidence_label"],
-            "top3": top3,
-            "inference_time_ms": inference_ms,
-        },
-        "ai_expert_verification": {
-            "crop_name":           ai.get("crop_name"),
-            "scientific_name":     ai.get("scientific_name"),
-            "characteristics":     ai.get("characteristics"),
-            "quality":             ai.get("quality"),
-            "market_grade":        ai.get("market_grade"),
-            "prediction_accuracy": ai.get("prediction_accuracy"),
-            "storage_tip":         ai.get("storage_tip"),
-            "explanation":         ai.get("explanation"),
-            "llama_time_ms":       llama_ms,
-        },
-        "model_version": "v6",
-        "request_by": key_info["name"],
-    }
+    if model is None:
+        raise HTTPException(503, detail="Model still loading or failed to load. Check /health.")
+    
+    img_bytes = await file.read()
+    if not img_bytes: raise HTTPException(422, detail="Empty image file.")
+    
+    processed = preprocess_image(img_bytes)
+    if processed is None:
+        raise HTTPException(422, detail="Invalid image file. Could not decode.")
 
+    try:
+        # Inference
+        res = model.predict(processed, verbose=0)[0]
+        top3_idx = np.argsort(res)[-3:][::-1]
+        top3 = [{"rank": i+1, "crop": class_names[idx].replace("_"," ").title(),
+                 "confidence_percent": round(float(res[idx])*100, 2),
+                 "confidence_label": confidence_label(round(float(res[idx])*100, 2))}
+                for i, idx in enumerate(top3_idx)]
+        
+        # LLaMA
+        ai = call_llama_vision(img_bytes, top3)
+        background_tasks.add_task(increment_usage, key_info["id"])
+        
+        return {
+            "success": True,
+            "final_answer": build_final_answer(top3, ai),
+            "model_prediction": {"top3": top3},
+            "ai_expert": ai,
+            "request_id": str(uuid.uuid4())
+        }
+    except Exception as e:
+        logger.error(f"Prediction failed: {e}")
+        raise HTTPException(500, detail={"error": "Prediction error", "message": str(e)})
 
-# ── PREDICT FAST (model only) ─────────────────────────────────────────────────
-@app.post("/predict/fast", tags=["Prediction"])
+@app.post("/predict/fast")
 async def predict_fast(
     background_tasks: BackgroundTasks,
     file: UploadFile = File(...),
     key_info: dict = Depends(validate_api_key),
 ):
-    """Fast prediction — model only, no LLaMA. Response in <500ms."""
-    request_id = str(uuid.uuid4())
-    image_bytes = await file.read()
-    if not image_bytes: raise HTTPException(422, "File is empty.")
-
-    t0 = time.time()
-    preds = model.predict(preprocess_image(image_bytes), verbose=0)[0]
-    inference_ms = round((time.time()-t0)*1000, 1)
-
-    top3_idx = np.argsort(preds)[-3:][::-1]
+    if model is None: raise HTTPException(503, detail="Model loading.")
+    img_bytes = await file.read()
+    processed = preprocess_image(img_bytes)
+    if processed is None: raise HTTPException(422, detail="Bad image.")
+    
+    res = model.predict(processed, verbose=0)[0]
+    top3_idx = np.argsort(res)[-3:][::-1]
     top3 = [{"rank": i+1, "crop": class_names[idx].replace("_"," ").title(),
-              "confidence_percent": round(float(preds[idx])*100, 2),
-              "confidence_label": confidence_label(round(float(preds[idx])*100, 2))}
-             for i, idx in enumerate(top3_idx)]
-
+             "confidence_percent": round(float(res[idx])*100, 2),
+             "confidence_label": confidence_label(round(float(res[idx])*100, 2))}
+            for i, idx in enumerate(top3_idx)]
+    
     background_tasks.add_task(increment_usage, key_info["id"])
-
-    return {
-        "success": True, "request_id": request_id,
-        "mode": "fast (model only)",
-        "top_prediction": top3[0]["crop"],
-        "confidence_percent": top3[0]["confidence_percent"],
-        "confidence_label": top3[0]["confidence_label"],
-        "top3": top3, "inference_time_ms": inference_ms,
-        "model_version": "v6", "request_by": key_info["name"],
-    }
+    return {"success": True, "top_prediction": top3[0]["crop"], "top3": top3}