patholens 2.0.0__py3-none-any.whl

patholens-2.0.0.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: patholens
+Version: 2.0.0
+Summary: A command-line tool to manage, deploy, and launch PathoLens with Google Colab or local backends.
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0.0
+Requires-Dist: fastapi>=0.110.0
+Requires-Dist: google-colab-cli>=0.1.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: openslide-bin>=4.0.1.1
+Requires-Dist: openslide-python>=1.3.0
+Requires-Dist: pillow>=10.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyjwt[crypto]>=2.8.0
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: uvicorn[standard]>=0.20.0
+Requires-Dist: websockets>=12.0
+Description-Content-Type: text/markdown
+
+# PathoLens
+
+PathoLens is a digital pathology workstation with a CLI launcher for local or Google Colab-backed execution.
+
+## Install
+
+```bash
+uv tool install patholens
+```
+
+## Usage
+
+```bash
+patholens launch
+```
+
+The launcher can run the backend locally or package and deploy the application to a Google Colab VM. Local launch builds the bundled Next.js UI if a static export is not already present.
+
+For whole-slide image viewing, the backend uses OpenSlide.

patholens-2.0.0.dist-info/RECORD

@@ -0,0 +1,45 @@
+patholens_cli/__init__.py,sha256=DjC2PAALKXLXdE-k7KEZE_2cTJ1Onz7ZQ462lvZe0Qk,45
+patholens_cli/main.py,sha256=M1Q4FY9XcMWd0lNDC7nL4pwgKCpPMq8D4hnxZL4hBeg,14813
+patholens-backend/requirements.txt,sha256=MsESWdUH1MlLjs2laxGDRfRvM7yaQ0Z9HAW08B8vQhY,116
+patholens-backend/app/database.py,sha256=38Sp4NnyCqa8xYOQT6HT5HU677QNzq0IUIymOkaSxpk,612
+patholens-backend/app/main.py,sha256=9N27gLdjBBTRvpLALzQZJXGd5HKPGT9IZMZn_7N74rc,20394
+patholens-backend/app/models.py,sha256=RH6fukqLrrTSD_s9zOcQIYPRxAwRnhR4d2m--i5eDX0,783
+patholens-ui/.gitignore,sha256=IH4mX_SQH5rZ-W2M4IUw4E-fxgCBVHKmbQpEYJbWVM0,480
+patholens-ui/OncoGemma-logo-no-bg_low.png,sha256=F0Sv8De15WgZwEDfTwqkiG4DJN1ni71IQ4uXBl1sWpc,80575
+patholens-ui/OncoGemma-no-bg-high_gemini.png,sha256=8yxHTdJl80v0Z11A5_YpnfUbt201aFZ478Bmbw3Mp-4,4690363
+patholens-ui/README.md,sha256=YLVf9995r3JZD5UkII5GZCvDK9wXXNrUE0loHA4vlY8,1450
+patholens-ui/eslint.config.mjs,sha256=hw8a3M7PMFHLzZ_TB871HXYzz1EJecGBqB9LF5cnNJM,465
+patholens-ui/next.config.ts,sha256=mjm5jrSGX-oaxtqnHLZWYDdWJoVx_BjMwr6PxNQcSdA,165
+patholens-ui/package-lock.json,sha256=hbndqurR7FrT3Fg9z-bsRnloqA0l7wRWKNc6_T6Y8_8,263654
+patholens-ui/package.json,sha256=-CMJZWDGneIsBcSgs_-rc9iVX1WN6A1N71VOixVgGB4,772
+patholens-ui/postcss.config.mjs,sha256=36x6wthtMmoOWtsCTnlDwYE5PtF6X8uPAxWyTH2m3d4,94
+patholens-ui/tsconfig.json,sha256=vhhSOyO3i24ah23dEH0zDwFovd8J11G1fgte3OacZvM,666
+patholens-ui/types.d.ts,sha256=0k2ku3FaCTnxalkLwihb3SLFYGwWzupkmyR3ZGwFySo,2088
+patholens-ui/app/favicon.ico,sha256=K4rS0zRVqPc2_DqOv48L3qiEitTA20iigzvQ-c13WTI,25931
+patholens-ui/app/globals.css,sha256=K7J-fRdhfeSsQXUdF4uZQ4_SdgkSc7XWloPxGQFtYJg,1634
+patholens-ui/app/layout.tsx,sha256=RpaajHuKYeCyUwEEYTf3lQ0YTyillt6HvyuEwyaJU9E,757
+patholens-ui/app/page.tsx,sha256=kWMNqbDdoeT5cHDxHYDM_0Lv92IXXCXSUfdHzJd4Oo0,102
+patholens-ui/app/dashboard/page.tsx,sha256=qgmVpyXEQL4Zj05prrQvrZ38P3CiWyM-AYn_ujo4qCs,14883
+patholens-ui/app/lib/auth.ts,sha256=DadfudKAkDNewK_I-pcsHjT20GtQCZLVfH0xcibph3s,1140
+patholens-ui/app/lib/config.ts,sha256=f2Lu7p9iyhOBEvxxFrMTdFE50vg8iSeu94t_pnmiDbQ,215
+patholens-ui/app/login/page.tsx,sha256=ffuO5za0CrCCeFGSNfjIbzLcOXb2JCs1Bm3pNOA0D8A,5516
+patholens-ui/app/viewer/page.tsx,sha256=MCR5Zwfq9QjIumDv2qLwuwqqBBe7jYonUBTlCGeEHLA,16926
+patholens-ui/components/AIResults.tsx,sha256=9oSyz6tkTrQSrdeiFPsoiuROvEjal513Wht2__tOKQk,8896
+patholens-ui/components/ClinicalChat.tsx,sha256=SoDC6Pa0ovnuQl-elBIYHsZ2rxrJYTqSu77wXZy6Vb8,3128
+patholens-ui/components/OncoLLM.tsx,sha256=LT3iej7X0JOoam9UNQlaTplQDtCaOaPGYzB1L4Cm3fI,8108
+patholens-ui/components/WSIViewer.tsx,sha256=71-9EK_CYZcp-_ShhWAABe2ZTETdToY4dv-wJDq0KlQ,4142
+patholens-ui/public/file.svg,sha256=K2eBLDJcGZoCU2zb7qDFk6cvcH0yO3LuPgjbqwZ1O9Q,391
+patholens-ui/public/globe.svg,sha256=thS5vxg5JZV2YayFFJj-HYAp_UOmL7_thvniYkpX588,1035
+patholens-ui/public/hawkfranklin_logo.png,sha256=JoICo2eNAgJvgSNzCBwqQFT4Dwh2h_1JR3La_lFcXyQ,1363659
+patholens-ui/public/next.svg,sha256=VZld-tbstJRaHoVt3KA8XhaqW_E_0htN9qdK55NXvPw,1375
+patholens-ui/public/onco-gemma-logo.png,sha256=OZFJ6KweMWYRNHhWF0NTsXIzUC7PMoE2KSJSg50b_W8,2110224
+patholens-ui/public/oncogemma_full_high_crop.png,sha256=41rIKPUTkouVUgFmjj-zMPqOahODmZuZQhuqeEcinw8,1974556
+patholens-ui/public/oncogemma_logo_only.png,sha256=ldo4ISCtJ8ucnCIyqWir8JAxsDzLVa4p4uvtx-WD8Vs,637917
+patholens-ui/public/oncogemma_text_only.png,sha256=lXZLJs-TEmLhVGfBbGaqkkBO-EJFkHJkhxjKoBhuF28,389460
+patholens-ui/public/pathogemma_icon.png,sha256=3NYUwgE-ESqjkkG_QqwDrtKVrENp4Txs0KGp4eNxiEg,303158
+patholens-ui/public/vercel.svg,sha256=8IEzey_uY1tFW2MnVAaj5_OdagFOJa2Q2rWmfmKhKsQ,128
+patholens-ui/public/window.svg,sha256=ZEdoxKrrR2e84pM0TusMEl-4BKlNgBRAQkByIC2F46E,385
+patholens-2.0.0.dist-info/METADATA,sha256=rQ9i-CXIxvY2LeT47oq74n4dNJN30Gkwacgvx4h7wxs,1161
+patholens-2.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+patholens-2.0.0.dist-info/entry_points.txt,sha256=DBH6XakxMTt4lHdHV8nCNvd-j1OdZdIj3viJrd5uxcY,53
+patholens-2.0.0.dist-info/RECORD,,

patholens-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

patholens-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+patholens = patholens_cli.main:cli

patholens-backend/app/database.py

@@ -0,0 +1,24 @@
+import os
+from sqlalchemy import create_engine
+from sqlalchemy.orm import declarative_base, sessionmaker
+
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///./patholens.db")
+
+# For SQLite, we need to allow multithreaded access
+if DATABASE_URL.startswith("sqlite"):
+    engine = create_engine(
+        DATABASE_URL, connect_args={"check_same_thread": False}
+    )
+else:
+    engine = create_engine(DATABASE_URL)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

patholens-backend/app/main.py

@@ -0,0 +1,541 @@
+import asyncio
+import io
+import json
+import logging
+import os
+import random
+import urllib.request
+from typing import List, Optional
+
+import httpx
+import openslide
+import pydantic
+import jwt
+from fastapi import FastAPI, HTTPException, WebSocket, Depends, Security
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from PIL import Image
+
+from .database import engine, Base, get_db
+from .models import User, Slide
+
+# Create DB tables on startup
+Base.metadata.create_all(bind=engine)
+
+try:
+    import litert_lm
+    LITERT_LM_AVAILABLE = True
+except ImportError:
+    LITERT_LM_AVAILABLE = False
+    logger = logging.getLogger("patholens-backend")
+    logger.warning("litert_lm package not found. LiteRT model local inference is disabled.")
+
+LITERT_ENGINE = None
+
+def get_litert_engine():
+    global LITERT_ENGINE
+    if not LITERT_LM_AVAILABLE:
+        raise HTTPException(status_code=500, detail="litert_lm package is not installed on this server")
+    if LITERT_ENGINE is None:
+        model_path = os.getenv("LITERT_MODEL_PATH")
+        if not model_path:
+            raise HTTPException(status_code=500, detail="LITERT_MODEL_PATH env var is not configured")
+        backend_str = os.getenv("LITERT_BACKEND", "cpu").lower()
+        backend = litert_lm.Backend.GPU if backend_str == "gpu" else litert_lm.Backend.CPU
+        logger.info("Initializing LiteRT-LM Engine with model: %s, backend: %s", model_path, backend_str)
+        LITERT_ENGINE = litert_lm.Engine(model_path, backend=backend)
+    return LITERT_ENGINE
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("patholens-backend")
+
+ALLOWED_ORIGINS = [
+    origin.strip()
+    for origin in os.getenv(
+        "CORS_ALLOW_ORIGINS",
+        "http://localhost:3000,http://127.0.0.1:3000",
+    ).split(",")
+    if origin.strip()
+]
+if not ALLOWED_ORIGINS:
+    ALLOWED_ORIGINS = ["*"]
+ALLOW_CREDENTIALS = not (len(ALLOWED_ORIGINS) == 1 and ALLOWED_ORIGINS[0] == "*")
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+DEFAULT_SLIDE_DIR = os.path.join(os.path.dirname(BASE_DIR), "cptac_samples")
+SLIDE_DIR = os.path.abspath(os.getenv("SAMPLE_DATA_PATH") or DEFAULT_SLIDE_DIR)
+
+STATIC_FRONTEND_DIR = os.getenv("STATIC_FRONTEND_DIR")
+STATIC_INDEX = os.path.join(STATIC_FRONTEND_DIR, "index.html") if STATIC_FRONTEND_DIR else None
+
+INFERENCE_API_URL = os.getenv("MEDGEMMA_API_URL") or os.getenv("INFERENCE_API_URL")
+INFERENCE_API_TOKEN = os.getenv("HF_TOKEN") or os.getenv("INFERENCE_API_TOKEN")
+INFERENCE_TIMEOUT = float(os.getenv("INFERENCE_TIMEOUT_SECONDS", "60"))
+SAMPLE_DEMO_URL = os.getenv("SAMPLE_DEMO_URL")
+SAMPLE_DEMO_FILENAME = os.getenv("SAMPLE_DEMO_FILENAME", "demo.svs")
+
+# Authentication configurations
+JWT_VERIFICATION_ENABLED = os.getenv("JWT_VERIFICATION_ENABLED", "false").lower() == "true"
+FIREBASE_PROJECT_ID = os.getenv("FIREBASE_PROJECT_ID")
+GOOGLE_PUBLIC_KEYS = {}
+
+async def fetch_google_public_keys():
+    global GOOGLE_PUBLIC_KEYS
+    try:
+        async with httpx.AsyncClient() as client:
+            res = await client.get("https://www.googleapis.com/robot/v1/metadata/x509/securetoken@system.gserviceaccount.com")
+            if res.status_code == 200:
+                GOOGLE_PUBLIC_KEYS = res.json()
+    except Exception as e:
+        logger.error("Failed to fetch Google public keys: %s", e)
+
+async def verify_firebase_token(token: str) -> dict:
+    if not GOOGLE_PUBLIC_KEYS:
+        await fetch_google_public_keys()
+    
+    try:
+        unverified_header = jwt.get_unverified_header(token)
+        kid = unverified_header.get("kid")
+        if not kid or kid not in GOOGLE_PUBLIC_KEYS:
+            raise HTTPException(status_code=401, detail="Invalid token header kid")
+        
+        cert = GOOGLE_PUBLIC_KEYS[kid]
+        decoded = jwt.decode(
+            token,
+            cert,
+            algorithms=["RS256"],
+            audience=FIREBASE_PROJECT_ID,
+            issuer=f"https://securetoken.google.com/{FIREBASE_PROJECT_ID}"
+        )
+        return decoded
+    except Exception as e:
+        logger.error("Token verification failed: %s", e)
+        raise HTTPException(status_code=401, detail=f"Token verification failed: {str(e)}")
+
+security = HTTPBearer(auto_error=False)
+
+async def get_current_user(
+    credentials: Optional[HTTPAuthorizationCredentials] = Security(security),
+    token: Optional[str] = None
+) -> dict:
+    if not JWT_VERIFICATION_ENABLED:
+        return {"user_id": "mock-user-id", "email": "doctor.sarah@oncogemma.com"}
+        
+    auth_token = None
+    if credentials:
+        auth_token = credentials.credentials
+    elif token:
+        auth_token = token
+        
+    if not auth_token:
+        raise HTTPException(status_code=401, detail="Authentication token required")
+        
+    decoded = await verify_firebase_token(auth_token)
+    return {
+        "user_id": decoded.get("sub"),
+        "email": decoded.get("email")
+    }
+
+def ensure_slide_storage():
+    os.makedirs(SLIDE_DIR, exist_ok=True)
+
+def maybe_download_demo_slide():
+    if not SAMPLE_DEMO_URL:
+        return
+    dest = os.path.join(SLIDE_DIR, SAMPLE_DEMO_FILENAME)
+    if os.path.exists(dest):
+        return
+    try:
+        logger.info("Downloading demo slide to %s", dest)
+        urllib.request.urlretrieve(SAMPLE_DEMO_URL, dest)
+    except Exception as exc:
+        logger.warning("Could not download demo slide: %s", exc)
+
+ensure_slide_storage()
+maybe_download_demo_slide()
+
+app = FastAPI()
+
+# CORS configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=ALLOWED_ORIGINS,
+    allow_credentials=ALLOW_CREDENTIALS,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+if STATIC_FRONTEND_DIR and os.path.isdir(STATIC_FRONTEND_DIR):
+    app.mount("/_static", StaticFiles(directory=STATIC_FRONTEND_DIR), name="frontend-static")
+
+def get_user_slide_path(filename: str, user_id: str) -> str:
+    # Check in user-specific folder (created via GCS FUSE mount or local)
+    path_user = os.path.join(SLIDE_DIR, "users", user_id, "slides", filename)
+    if os.path.exists(path_user):
+        return path_user
+    
+    # Fallback to local root (default slides/demo)
+    path_fallback = os.path.join(SLIDE_DIR, filename)
+    return path_fallback
+
+class SlideManager:
+    def __init__(self):
+        # Maps user_id -> {'slide': OpenSlide, 'dz': DeepZoomGenerator, 'name': filename}
+        self.active_sessions = {}
+
+    def get_session(self, user_id: str):
+        return self.active_sessions.get(user_id)
+
+    def load(self, filename: str, user_id: str):
+        path = get_user_slide_path(filename, user_id)
+        if not os.path.exists(path):
+            raise HTTPException(status_code=404, detail=f"Slide not found: {filename}")
+        
+        try:
+            slide = openslide.OpenSlide(path)
+            from openslide.deepzoom import DeepZoomGenerator
+            dz = DeepZoomGenerator(slide, tile_size=256, overlap=0, limit_bounds=False)
+            self.active_sessions[user_id] = {
+                'slide': slide,
+                'dz': dz,
+                'name': filename
+            }
+            logger.info("Loaded slide for user %s: %s", user_id, path)
+            return True
+        except Exception as e:
+            logger.exception("Error loading slide: %s", e)
+            raise HTTPException(status_code=500, detail=f"Failed to load slide: {str(e)}")
+
+slide_manager = SlideManager()
+
+# Load default if available (fallback compatibility for local testing)
+try:
+    if os.path.exists(SLIDE_DIR):
+        files = [f for f in os.listdir(SLIDE_DIR) if f.endswith('.svs')]
+        if files:
+            slide_manager.load(files[0], "mock-user-id")
+            logger.info("Loaded default slide %s for mock-user-id", files[0])
+except Exception:
+    pass
+
+@app.get("/slides")
+async def list_slides(current_user: dict = Depends(get_current_user)):
+    """List all available SVS slides for the current user."""
+    user_id = current_user["user_id"]
+    user_slide_dir = os.path.join(SLIDE_DIR, "users", user_id, "slides")
+    
+    slides = []
+    if os.path.exists(user_slide_dir):
+        slides = [f for f in os.listdir(user_slide_dir) if f.endswith('.svs')]
+    
+    if os.path.exists(SLIDE_DIR):
+        root_slides = [f for f in os.listdir(SLIDE_DIR) if f.endswith('.svs')]
+        for s in root_slides:
+            if s not in slides:
+                slides.append(s)
+                
+    session = slide_manager.get_session(user_id)
+    return {
+        "slides": slides,
+        "current": session['name'] if session else None
+    }
+
+class LoadSlideRequest(pydantic.BaseModel):
+    filename: str
+
+@app.post("/load_slide")
+async def load_slide(request: LoadSlideRequest, current_user: dict = Depends(get_current_user)):
+    """Load a specific slide for the current user."""
+    user_id = current_user["user_id"]
+    slide_manager.load(request.filename, user_id)
+    return {"status": "success", "filename": request.filename}
+
+@app.get("/")
+async def root():
+    if STATIC_INDEX and os.path.isfile(STATIC_INDEX):
+        return FileResponse(STATIC_INDEX)
+    return {"message": "PathoLens Backend is running"}
+
+@app.get("/metadata")
+async def get_metadata(current_user: dict = Depends(get_current_user)):
+    user_id = current_user["user_id"]
+    session = slide_manager.get_session(user_id)
+    if not session or not session.get('slide'):
+        raise HTTPException(status_code=404, detail="Slide not loaded for current user")
+    
+    slide = session['slide']
+    return {
+        "width": slide.dimensions[0],
+        "height": slide.dimensions[1],
+        "level_count": slide.level_count,
+        "level_dimensions": slide.level_dimensions,
+        "level_downsamples": slide.level_downsamples,
+        "filename": session['name']
+    }
+
+@app.get("/tiles/{level}/{x}/{y}")
+async def get_tile(level: int, x: int, y: int, current_user: dict = Depends(get_current_user)):
+    user_id = current_user["user_id"]
+    session = slide_manager.get_session(user_id)
+    if not session or not session.get('dz'):
+        raise HTTPException(status_code=404, detail="Slide not loaded for current user")
+    
+    try:
+        dz = session['dz']
+        if level < 0 or level >= dz.level_count:
+             raise HTTPException(status_code=404, detail="Level out of bounds")
+
+        tile = dz.get_tile(level, (x, y))
+            
+        img_byte_arr = io.BytesIO()
+        tile.save(img_byte_arr, format='JPEG')
+        img_byte_arr.seek(0)
+        
+        return StreamingResponse(img_byte_arr, media_type="image/jpeg")
+
+    except ValueError:
+        raise HTTPException(status_code=404, detail="Tile out of bounds")
+    except Exception as e:
+        logger.exception("Error serving tile: %s", e)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/dzi")
+async def get_dzi(current_user: dict = Depends(get_current_user)):
+    """
+    Return DZI metadata for OpenSeadragon for current user session.
+    """
+    user_id = current_user["user_id"]
+    session = slide_manager.get_session(user_id)
+    if not session or not session.get('dz'):
+        raise HTTPException(status_code=404, detail="Slide not loaded for current user")
+        
+    dz = session['dz']
+    
+    return {
+        "Image": {
+            "xmlns": "http://schemas.microsoft.com/deepzoom/2008",
+            "Format": "jpeg",
+            "Overlap": "0",
+            "TileSize": "256",
+            "Size": {
+                "Width": str(dz.level_dimensions[-1][0]),
+                "Height": str(dz.level_dimensions[-1][1])
+            }
+        }
+    }
+
+# Inference proxy (to external endpoints such as HF Inference Endpoint, Gradio Space, or custom vLLM/TGI).
+class InferenceRequest(pydantic.BaseModel):
+    prompt: str
+    images: Optional[List[str]] = None
+    parameters: dict = {}
+
+async def forward_inference(payload: dict, endpoint: Optional[str] = None):
+    target = endpoint or INFERENCE_API_URL
+    if not target:
+        raise HTTPException(status_code=503, detail="Inference endpoint not configured")
+
+    headers = {"Content-Type": "application/json"}
+    if INFERENCE_API_TOKEN:
+        headers["Authorization"] = f"Bearer {INFERENCE_API_TOKEN}"
+
+    try:
+        async with httpx.AsyncClient(timeout=INFERENCE_TIMEOUT) as client:
+            response = await client.post(target, json=payload, headers=headers)
+        response.raise_for_status()
+    except httpx.HTTPStatusError as exc:
+        detail = exc.response.text if exc.response else str(exc)
+        logger.error("Inference endpoint returned an error: %s", detail)
+        raise HTTPException(
+            status_code=exc.response.status_code if exc.response else 502,
+            detail=f"Inference failed: {detail}",
+        ) from exc
+    except httpx.HTTPError as exc:
+        logger.error("Inference request failed: %s", exc)
+        raise HTTPException(status_code=502, detail=f"Inference request failed: {exc}") from exc
+
+    try:
+        return response.json()
+    except Exception:
+        return {"raw": response.text}
+
+@app.post("/api/ai/diagnose")
+async def proxy_diagnose(request: InferenceRequest, current_user: dict = Depends(get_current_user)):
+    """
+    Proxy AI analysis to an external inference endpoint.
+    """
+    payload = {"prompt": request.prompt}
+    if request.images:
+        payload["images"] = request.images
+    if request.parameters:
+        payload["parameters"] = request.parameters
+
+    return await forward_inference(payload)
+
+# Dummy AI Endpoints
+
+@app.get("/ai/summary")
+async def get_global_summary(current_user: dict = Depends(get_current_user)):
+    await asyncio.sleep(1) # Simulate latency
+    return {
+        "description": "The slide shows sections of squamous cell carcinoma with moderate differentiation. "
+                   "There is significant keratin pearl formation and intercellular bridges. "
+                   "The stroma shows a heavy inflammatory infiltrate, primarily lymphocytic. "
+                   "Tumor margins appear infiltrative.",
+        "confidence": 0.92
+    }
+
+@app.get("/ai/risk")
+async def get_risk_score(current_user: dict = Depends(get_current_user)):
+    await asyncio.sleep(1.5)
+    return {
+        "score": 0.87,
+        "risk_level": "High",
+        "factors": [
+            {"name": "Tumor Budding", "value": "High"},
+            {"name": "Stromal Reaction", "value": "Desmoplastic"},
+            {"name": "Lymphocytic Infiltration", "value": "Moderate"}
+        ]
+    }
+
+@app.get("/ai/biomarkers")
+async def get_biomarkers(current_user: dict = Depends(get_current_user)):
+    await asyncio.sleep(0.5)
+    return {
+        "detected": [
+            {"name": "EGFR", "status": "Overexpression", "location": [10000, 10000]},
+            {"name": "TP53", "status": "Mutated", "location": [15000, 12000]},
+            {"name": "CD274 (PD-L1)", "status": "Positive", "location": [5000, 8000]}
+        ]
+    }
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    try:
+        while True:
+            data = await websocket.receive_text()
+            if "analyze_region" in data:
+                await asyncio.sleep(0.5)
+                await websocket.send_json({
+                    "type": "analysis_result",
+                    "content": {
+                        "cell_count": random.randint(50, 200),
+                        "tissue_type": random.choice(["Tumor", "Stroma", "Necrosis", "Normal"]),
+                        "mitotic_index": random.choice(["Low", "Moderate", "High"])
+                    }
+                })
+    except Exception:
+        pass
+
+# PathoLens 2.0 Mock Endpoints
+
+@app.get("/ai/tumor_burden")
+async def get_tumor_burden(current_user: dict = Depends(get_current_user)):
+    await asyncio.sleep(0.8)
+    return {
+        "percentage": 68.5,
+        "description": "High tumor burden observed in ROI.",
+        "location_count": 12
+    }
+
+@app.get("/ai/subtyping")
+async def get_subtyping(current_user: dict = Depends(get_current_user)):
+    await asyncio.sleep(1.2)
+    return [
+        {"name": "Invasive Ductal Carcinoma", "probability": 0.85, "description": "Most likely subtype based on glandular patterns."},
+        {"name": "Invasive Lobular Carcinoma", "probability": 0.10, "description": "Secondary possibility."},
+        {"name": "Ductal Carcinoma In Situ", "probability": 0.05, "description": "Minor component observed."}
+    ]
+
+@app.get("/ai/toxicity")
+async def get_toxicity(current_user: dict = Depends(get_current_user)):
+    await asyncio.sleep(1.0)
+    return [
+        {
+            "treatment_type": "Chemotherapy",
+            "risk_level": "Moderate",
+            "probability": 0.45,
+            "potential_side_effects": ["Neutropenia", "Fatigue"]
+        },
+        {
+            "treatment_type": "Immunotherapy",
+            "risk_level": "Low",
+            "probability": 0.15,
+            "potential_side_effects": ["Mild Rash"]
+        }
+    ]
+
+class OncoLLMQuery(pydantic.BaseModel):
+    query: str
+    context: dict = {}
+
+@app.post("/ai/oncollm/query")
+async def query_oncollm(request: OncoLLMQuery, current_user: dict = Depends(get_current_user)):
+    model_path = os.getenv("LITERT_MODEL_PATH")
+    if model_path:
+        try:
+            engine = get_litert_engine()
+            with engine.create_conversation() as conversation:
+                response = conversation.send_message(request.query)
+                
+                # Safe attribute check on the conversation response
+                raw_text = ""
+                if hasattr(response, 'text'):
+                    raw_text = response.text
+                elif hasattr(response, 'content'):
+                    raw_text = response.content
+                else:
+                    raw_text = str(response)
+                    
+            return {
+                "content": raw_text,
+                "references": []
+            }
+        except Exception as e:
+            logger.error("LiteRT-LM local inference failed: %s", e)
+            raise HTTPException(status_code=500, detail=f"LiteRT-LM local inference failed: {str(e)}")
+
+    await asyncio.sleep(2.0)
+    query_lower = request.query.lower()
+    
+    if "treatment" in query_lower:
+        return {
+            "content": f"Hello {current_user.get('email', 'Doctor')}. Based on the high tumor burden (68.5%) and EGFR overexpression, a combination of chemotherapy and targeted therapy (e.g., Cetuximab) is recommended. However, note the moderate risk of chemotherapy-induced neutropenia.",
+            "references": [
+                {"title": "EGFR Inhibition in Squamous Cell Carcinoma", "authors": "Smith et al.", "year": 2023, "url": "#", "relevance_score": 0.95},
+                {"title": "Managing Neutropenia in High-Burden Cases", "authors": "Doe et al.", "year": 2022, "url": "#", "relevance_score": 0.88}
+            ]
+        }
+    elif "prognosis" in query_lower:
+        return {
+            "content": f"For the patient case under review, the prognosis is guarded due to the 'High Risk' classification and infiltrative margins. The 5-year survival rate for this subtype with similar biomarkers is approximately 60% without aggressive intervention.",
+            "references": [
+                {"title": "Prognostic Factors in Invasive Carcinoma", "authors": "Lee et al.", "year": 2024, "url": "#", "relevance_score": 0.92}
+            ]
+        }
+    else:
+        return {
+            "content": "I've analyzed the slide context. The tissue shows clear signs of malignancy with significant inflammatory infiltration. Would you like to explore specific treatment options or biomarker implications?",
+            "references": []
+        }
+
+@app.get("/{full_path:path}")
+async def serve_frontend(full_path: str):
+    """
+    Serve the exported Next.js frontend when running in a single-container setup.
+    """
+    if not STATIC_FRONTEND_DIR or not os.path.isdir(STATIC_FRONTEND_DIR):
+        raise HTTPException(status_code=404, detail="Not Found")
+
+    candidate = os.path.join(STATIC_FRONTEND_DIR, full_path)
+    if os.path.isfile(candidate):
+        return FileResponse(candidate)
+
+    if STATIC_INDEX and os.path.isfile(STATIC_INDEX):
+        return FileResponse(STATIC_INDEX)
+
+    raise HTTPException(status_code=404, detail="Not Found")
+

patholens-backend/app/models.py

@@ -0,0 +1,17 @@
+from sqlalchemy import Column, String, ForeignKey, DateTime, Integer
+from sqlalchemy.sql import func
+from .database import Base
+
+class User(Base):
+    __tablename__ = 'users'
+    id = Column(String, primary_key=True)  # Matches Auth provider UID (Firebase/Identity Platform)
+    email = Column(String, unique=True, nullable=False)
+    created_at = Column(DateTime, server_default=func.now())
+
+class Slide(Base):
+    __tablename__ = 'slides'
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    filename = Column(String, nullable=False)
+    gcs_uri = Column(String, nullable=True)  # Storage path in GCS if applicable
+    owner_id = Column(String, ForeignKey('users.id', ondelete='CASCADE'), nullable=False)
+    uploaded_at = Column(DateTime, server_default=func.now())