update

Makefile

@@ -19,9 +19,9 @@ run:
 	$(VENV_DIR)/Scripts/python app.py
 
 # Remove virtual environment
-clean:
+clean-all:
 	if exist $(VENV_DIR) rmdir /s /q $(VENV_DIR)
 
 # Clean caches (__pycache__, .pytest_cache, *.pyc, *.pyo, build artifacts) - preserve .venv
-clean-all:
+clean:
 	- powershell -Command "Get-ChildItem -Recurse -Force -Include __pycache__,*.pyc,*.pyo,.pytest_cache,build,dist | Remove-Item -Recurse -Force"

app/routers/agent_chat.py

@@ -2,8 +2,10 @@
 import asyncio
 import json
 import logging
+import os
+from datetime import datetime
 
-from fastapi import APIRouter, Depends, Header, HTTPException
+from fastapi import APIRouter, Depends, File, Form, Header, HTTPException, UploadFile
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
@@ -84,28 +86,143 @@ async def stream_agent_response(agent_service: GoogleAgentService, query: str):
 
 @router.post("/agent-chat")
 async def agent_chat(
-    request: AgentChatRequest,
     authorization: str = Header(None),
     username: str = Depends(get_current_user),
+    session_id: Optional[str] = Form(None),
+    query: Optional[str] = Form(None),
+    file: Optional[UploadFile] = File(None),
+    image: Optional[UploadFile] = File(None),
 ):
     if not authorization or not authorization.startswith("Bearer "):
         raise HTTPException(status_code=401, detail="Invalid authorization header")
 
     token = authorization.split(" ", 1)[1]
 
+    # Handle file/image uploads if present
+    document_info = None
+    image_info = None
+    
+    # Setup upload directory
+    default_upload_root = os.path.abspath(
+        os.path.join(os.path.dirname(__file__), "..", "..", "uploads")
+    )
+    uploads_root = os.getenv('DERMAI_UPLOAD_DIR', default_upload_root)
+    
+    # Handle document upload
+    if file:
+        try:
+            # Validate file type
+            file_extension = file.filename.rsplit('.', 1)[1].lower() if '.' in file.filename else ''
+            allowed_doc_extensions = {
+                'pdf', 'xlsx', 'xls', 'csv', 'doc', 'docx', 
+                'ppt', 'pptx', 'txt', 'html'
+            }
+            
+            if file_extension not in allowed_doc_extensions:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Unsupported file type. Allowed types: {', '.join(sorted(allowed_doc_extensions))}"
+                )
+            
+            # Create session directory
+            session_upload_dir = os.path.join(uploads_root, session_id or "temp")
+            os.makedirs(session_upload_dir, exist_ok=True)
+            
+            # Save file
+            timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
+            sanitized_name = file.filename.replace(' ', '_')
+            stored_filename = f"{timestamp}_{sanitized_name}"
+            stored_path = os.path.join(session_upload_dir, stored_filename)
+            
+            content = await file.read()
+            with open(stored_path, 'wb') as f:
+                f.write(content)
+            
+            # Create document info
+            relative_path = os.path.relpath(stored_path, uploads_root).replace('\\', '/')
+            document_info = {
+                'path': relative_path,
+                'name': file.filename,
+                'type': file.content_type,
+                'extension': file_extension,
+            }
+            
+            # Auto-generate query if not provided
+            if not query:
+                query = f"Please analyze the uploaded document: {file.filename}"
+                
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(f"Error handling document upload: {e}")
+            raise HTTPException(status_code=500, detail="Failed to process document")
+    
+    # Handle image upload
+    if image:
+        try:
+            # Validate image type
+            file_extension = image.filename.rsplit('.', 1)[1].lower() if '.' in image.filename else ''
+            allowed_image_extensions = {
+                "jpg", "jpeg", "png"
+            }
+            
+            if file_extension not in allowed_image_extensions:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Unsupported image type. Allowed types: {', '.join(sorted(allowed_image_extensions))}"
+                )
+            
+            # Create session directory
+            session_upload_dir = os.path.join(uploads_root, session_id or "temp")
+            os.makedirs(session_upload_dir, exist_ok=True)
+            
+            # Save image
+            timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
+            sanitized_name = image.filename.replace(' ', '_')
+            stored_filename = f"{timestamp}_{sanitized_name}"
+            stored_path = os.path.join(session_upload_dir, stored_filename)
+            
+            content = await image.read()
+            with open(stored_path, 'wb') as f:
+                f.write(content)
+            
+            # Create image info
+            relative_path = os.path.relpath(stored_path, uploads_root).replace('\\', '/')
+            image_info = {
+                'path': relative_path,
+                'name': image.filename,
+                'type': image.content_type,
+                'extension': file_extension,
+                'prompt': query,
+            }
+            
+            # Auto-generate query if not provided
+            if not query:
+                query = f"Please analyze this skin image: {image.filename}"
+                
+        except HTTPException:
+            raise
+        except Exception as e:
+            logger.error(f"Error handling image upload: {e}")
+            raise HTTPException(status_code=500, detail="Failed to process image")
+    
+    # Ensure we have a query
+    if not query:
+        raise HTTPException(status_code=400, detail="Query text is required")
+
     try:
         agent_service = GoogleAgentService(
             token=token,
-            session_id=request.session_id,
-            document=request.document.dict() if request.document else None,
-            image=request.image.dict() if request.image else None,
+            session_id=session_id,
+            document=document_info,
+            image=image_info,
         )
     except Exception as exc:
         logger.error("Failed to initialise agent service: %s", exc, exc_info=True)
         raise HTTPException(status_code=500, detail="Unable to initialise agent")
 
     return StreamingResponse(
-        stream_agent_response(agent_service, request.query),
+        stream_agent_response(agent_service, query),
         media_type="text/event-stream",
         headers={
             "Cache-Control": "no-cache",
@@ -130,6 +247,8 @@ async def agent_status(username: str = Depends(get_current_user)):
                 "image_search",
                 "streaming",
                 "tool_calls",
+                "file_upload",
+                "image_upload",
             ],
         }
     except Exception as exc:

app/routers/chat.py

@@ -188,91 +188,6 @@ async def export_all_chats(username: str = Depends(get_current_user)):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-@router.post('/report-analysis')
-async def upload_report(
-    file: UploadFile = File(...),
-    session_id: str = Form(...),
-    authorization: str = Header(None),
-    username: str = Depends(get_current_user)
-):
-    try:
-        _ = authorization.split(" ")[1]
-
-        if not file.filename:
-            return JSONResponse(
-                status_code=400,
-                content={"status": "error", "error": "Empty file provided"}
-            )
-
-        file_extension = file.filename.rsplit('.', 1)[1].lower() if '.' in file.filename else ''
-        allowed_extensions = {
-            'pdf',
-            'xlsx',
-            'xls',
-            'csv',
-            'jpg',
-            'jpeg',
-            'png',
-            'doc',
-            'docx',
-            'ppt',
-            'pptx',
-            'txt',
-            'html'
-        }
-
-        if file_extension not in allowed_extensions:
-            return JSONResponse(
-                status_code=400,
-                content={
-                    "status": "error",
-                    "error": f"Unsupported file type. Allowed types: {', '.join(sorted(allowed_extensions))}",
-                }
-            )
-
-        default_upload_root = os.path.abspath(
-            os.path.join(os.path.dirname(__file__), "..", "..", "uploads")
-        )
-        uploads_root = os.getenv('DERMAI_UPLOAD_DIR', default_upload_root)
-        session_upload_dir = os.path.join(uploads_root, session_id)
-        os.makedirs(session_upload_dir, exist_ok=True)
-
-        timestamp = datetime.utcnow().strftime('%Y%m%d%H%M%S%f')
-        sanitized_name = file.filename.replace(' ', '_')
-        stored_filename = f"{timestamp}_{sanitized_name}"
-        stored_path = os.path.join(session_upload_dir, stored_filename)
-
-        content = await file.read()
-        with open(stored_path, 'wb') as f:
-            f.write(content)
-
-        relative_root = os.path.abspath(uploads_root)
-        absolute_path = os.path.abspath(stored_path)
-        relative_path = os.path.relpath(absolute_path, relative_root)
-
-        return {
-            "status": "success",
-            "message": "File uploaded successfully",
-            "file": {
-                "path": relative_path.replace('\\', '/'),
-                "name": file.filename,
-                "content_type": file.content_type,
-                "size": len(content),
-                "extension": file_extension,
-            }
-        }
-
-    except Exception as e:
-        logging.error(f"Error in upload_report: {str(e)}")
-        raise HTTPException(
-            status_code=500,
-            detail={
-                "status": "error",
-                "error": "Internal server error",
-                "details": str(e)
-            }
-        )
-
 @router.get('/skin-care-schedule')
 async def get_skin_care_schedule(
     authorization: str = Header(None),

test_skin_analysis.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple test script to verify that the modified analyze_skin_image function works correctly
-without the skin-vs-non-skin classification step.
-"""
-
-import os
-import sys
-from pathlib import Path
-
-# Add the app directory to the Python path
-sys.path.insert(0, str(Path(__file__).parent / "app"))
-
-from services.tools import analyze_skin_image
-
-
-def test_analyze_skin_image():
-    """Test the analyze_skin_image function with a sample image."""
-    
-    # Find the first available image in uploads
-    uploads_dir = Path("uploads")
-    image_files = []
-    
-    for subdir in uploads_dir.iterdir():
-        if subdir.is_dir():
-            for file in subdir.iterdir():
-                if file.suffix.lower() in ['.jpg', '.jpeg', '.png']:
-                    image_files.append(file)
-                    break
-        if image_files:
-            break
-    
-    if not image_files:
-        print("No image files found in uploads directory for testing")
-        return False
-    
-    test_image = image_files[0]
-    print(f"Testing with image: {test_image}")
-
-    # Use relative path from uploads directory
-    relative_path = test_image.relative_to(uploads_dir)
-    print(f"Using relative path: {relative_path}")
-
-    # Test the function
-    try:
-        result = analyze_skin_image(str(relative_path))
-        
-        print("=== Test Results ===")
-        print(f"Status: {result.get('status')}")
-        print(f"Is skin: {result.get('is_skin')}")
-        
-        if result.get('status') == 'success':
-            if result.get('diagnosis'):
-                print(f"Diagnosis: {result.get('diagnosis')}")
-                print(f"Confidence: {result.get('confidence')}%")
-            else:
-                print("No diagnosis (confidence below threshold)")
-                print(f"Confidence: {result.get('confidence')}%")
-            
-            print(f"Message: {result.get('message')}")
-            print("✅ Test passed - function executed successfully")
-            return True
-        else:
-            print(f"❌ Test failed - Error: {result.get('error_message')}")
-            return False
-            
-    except Exception as e:
-        print(f"❌ Test failed with exception: {e}")
-        return False
-
-
-if __name__ == "__main__":
-    print("Testing modified analyze_skin_image function...")
-    print("This test verifies that skin disease classification works directly without skin-vs-non-skin pre-classification.")
-    print()
-    
-    success = test_analyze_skin_image()
-    
-    if success:
-        print("\n🎉 All tests passed! The skin disease classification is working correctly.")
-    else:
-        print("\n💥 Tests failed. Please check the error messages above.")
-    
-    sys.exit(0 if success else 1)