fix

py_backend/app/routers/caption.py

@@ -44,7 +44,11 @@ if settings.HF_API_KEY:
         try:
             models = crud.get_models(db)
             for model in models:
-                if model.provider == "huggingface" and model.model_id and model.m_code != "STUB_MODEL":
+               
+                if (model.provider == "huggingface" and 
+                    model.model_id and 
+                    model.m_code != "STUB_MODEL" and
+                    model.m_code not in ["GPT-4O", "GEMINI15"]):  
                     try:
                         service = ProvidersGenericVLMService(
                             api_key=settings.HF_API_KEY,
@@ -89,8 +93,6 @@ async def create_caption(
     db: Session = Depends(get_db),
 ):
     print(f"📝 Caption Router: Starting caption generation for image {image_id}")
-    print(f"📝 Caption Router: Title: {title}")
-    print(f"📝 Caption Router: Prompt: {prompt}")
     print(f"📝 Caption Router: Requested model: {model_name}")
     
     # Get the image
@@ -99,16 +101,12 @@ async def create_caption(
         print(f"❌ Caption Router: Image {image_id} not found")
         raise HTTPException(404, f"Image {image_id} not found")
     
-    print(f"📝 Caption Router: Image found: {img.file_key}, type: {img.image_type}")
-    
     # Get the prompt object
     prompt_obj = crud.get_prompt(db, prompt)
     if not prompt_obj:
         print(f"❌ Caption Router: Prompt '{prompt}' not found")
         raise HTTPException(400, f"Prompt '{prompt}' not found")
     
-    print(f"📝 Caption Router: Prompt found: {prompt_obj.p_code}")
-    
     # Get image bytes
     try:
         if hasattr(storage, 's3') and settings.STORAGE_PROVIDER != "local":
@@ -122,7 +120,6 @@ async def create_caption(
             file_path = os.path.join(settings.STORAGE_DIR, img.file_key)
             with open(file_path, 'rb') as f:
                 img_bytes = f.read()
-        print(f"📝 Caption Router: Image bytes retrieved: {len(img_bytes)} bytes")
     except Exception as e:
         print(f"❌ Caption Router: Failed to get image bytes: {e}")
         raise HTTPException(500, f"Failed to get image: {e}")
@@ -131,76 +128,63 @@ async def create_caption(
     metadata_instructions = ""
     if img.image_type == "drone_image":
         metadata_instructions = f"Image type: drone image. Center coordinates: {img.center_lon}, {img.center_lat}. Altitude: {img.amsl_m}m AMSL, {img.agl_m}m AGL. Heading: {img.heading_deg}°, Yaw: {img.yaw_deg}°, Pitch: {img.pitch_deg}°, Roll: {img.roll_deg}°. RTK fix: {img.rtk_fix}. Standard deviations: H={img.std_h_m}m, V={img.std_v_m}m."
-        print(f"📝 Caption Router: Drone metadata instructions prepared")
     else:
         metadata_instructions = f"Image type: crisis map. Source: {img.source}. Event type: {img.event_type}. EPSG: {img.epsg}. Countries: {img.countries}."
-        print(f"📝 Caption Router: Crisis map metadata instructions prepared")
     
     print(f"📝 Caption Router: Calling VLM manager...")
     
-    metadata = {}
+    # Call VLM manager
     try:
         result = await vlm_manager.generate_caption(
-            image_bytes=img_bytes,
+            image_bytes=img_bytes, 
             prompt=prompt_obj.label,
             metadata_instructions=metadata_instructions,
             model_name=model_name,
             db_session=db,
         )
-        
-        print(f"📝 Caption Router: VLM manager returned result")
-        print(f"📝 Caption Router: Result keys: {list(result.keys())}")
-        print(f"📝 Caption Router: Model used: {result.get('model')}")
-        print(f"📝 Caption Router: Fallback used: {result.get('fallback_used')}")
-        
-        # Get the raw response for validation
-        raw = result.get("raw_response", {})
-        
-        # Validate and clean the data using schema validation
-        image_type = img.image_type
-        print(f"📝 Caption Router: Validating data for image type: {image_type}")
-        print(f"📝 Caption Router: Raw data structure: {list(raw.keys()) if isinstance(raw, dict) else 'Not a dict'}")
-        
-        cleaned_data, is_valid, validation_error = schema_validator.clean_and_validate_data(raw, image_type)
-        
-        if is_valid:
-            print(f"✅ Caption Router: Schema validation passed for {image_type}")
-            text = cleaned_data.get("analysis", "")
-            metadata = cleaned_data.get("metadata", {})
-        else:
-            print(f"⚠️ Caption Router: Schema validation failed for {image_type}: {validation_error}")
-            # Use fallback but log the validation error
-            text = result.get("caption", "This is a fallback caption due to schema validation error.")
-            metadata = result.get("metadata", {})
-            raw["validation_error"] = validation_error
-            raw["validation_failed"] = True
-        
-        # Use the actual model that was used, not the requested model_name
-        used_model = result.get("model", model_name) or "STUB_MODEL"
-        
-        # Check if fallback was used
-        fallback_used = result.get("fallback_used", False)
-        original_model = result.get("original_model", None)
-        fallback_reason = result.get("fallback_reason", None)
-        
-        if fallback_used:
-            print(f"⚠️ Caption Router: Model fallback occurred: {original_model} -> {used_model} (reason: {fallback_reason})")
-            # Add fallback info to raw response for frontend
-            raw["fallback_info"] = {
-                "original_model": original_model,
-                "fallback_model": used_model,
-                "reason": fallback_reason
-            }
-        else:
-            print(f"✅ Caption Router: No fallback used, primary model {used_model} succeeded")
-        
     except Exception as e:
-        print(f"❌ Caption Router: VLM error, using fallback: {e}")
-        print(f"❌ Caption Router: Error type: {type(e).__name__}")
-        text = "This is a fallback caption due to VLM service error."
-        used_model = "STUB_MODEL"
-        raw = {"error": str(e), "fallback": True}
-        metadata = {}
+        print(f"❌ Caption Router: VLM manager failed: {e}")
+        raise HTTPException(500, f"Caption generation failed: {e}")
+    
+    print(f"📝 Caption Router: VLM manager returned result")
+    
+    # Get the raw response for validation
+    raw = result.get("raw_response", {})
+    
+    # Validate and clean the data using schema validation
+    image_type = img.image_type
+    print(f"📝 Caption Router: Validating data for image type: {image_type}")
+    
+    cleaned_data, is_valid, validation_error = schema_validator.clean_and_validate_data(raw, image_type)
+    
+    if is_valid:
+        print(f"✅ Caption Router: Schema validation passed for {image_type}")
+        text = cleaned_data.get("analysis", "")
+        metadata = cleaned_data.get("metadata", {})
+    else:
+        print(f"⚠️ Caption Router: Schema validation failed for {image_type}: {validation_error}")
+        # Use fallback but log the validation error
+        text = result.get("caption", "This is a fallback caption due to schema validation error.")
+        metadata = result.get("metadata", {})
+        raw["validation_error"] = validation_error
+        raw["validation_failed"] = True
+    
+    # Use the actual model that was used, not the requested model_name
+    used_model = result.get("model", model_name) or "STUB_MODEL"
+    
+    # Check if fallback was used
+    fallback_used = result.get("fallback_used", False)
+    original_model = result.get("original_model", None)
+    fallback_reason = result.get("fallback_reason", None)
+    
+    if fallback_used:
+        print(f"⚠️ Caption Router: Model fallback occurred: {original_model} -> {used_model} (reason: {fallback_reason})")
+        # Add fallback info to raw response for frontend
+        raw["fallback_info"] = {
+            "original_model": original_model,
+            "fallback_model": used_model,
+            "reason": fallback_reason
+        }
     
     print(f"📝 Caption Router: Creating caption in database...")
     
@@ -218,20 +202,14 @@ async def create_caption(
     db.refresh(c)
     
     print(f"📝 Caption Router: Caption created successfully")
-    print(f"📝 Caption Router: Caption ID: {c.image_id}")
-    print(f"📝 Caption Router: Model used: {c.model}")
     
     from .upload import convert_image_to_dict
     try:
         url = storage.get_object_url(c.file_key)
-        print(f"📝 Caption Router: Generated URL: {url}")
         if url.startswith('/') and settings.STORAGE_PROVIDER == "local":
             url = f"http://localhost:8000{url}"
-            print(f"📝 Caption Router: Local URL adjusted to: {url}")
     except Exception as e:
-        print(f"⚠️ Caption Router: URL generation failed: {e}")
         url = f"/api/images/{c.image_id}/file"
-        print(f"📝 Caption Router: Using fallback URL: {url}")
     
     img_dict = convert_image_to_dict(c, url)
     print(f"📝 Caption Router: Caption generation completed successfully")

py_backend/app/services/gemini_service.py

@@ -84,53 +84,18 @@ class GeminiService(VLMService):
             print(f"❌ Gemini: Error type: {error_type}")
             print(f"❌ Gemini: Error message: {error_msg}")
             
-            # Capture Google Gemini API specific error details
-            provider_error_details = {}
-            
-            # Check for Google API specific errors
-            if hasattr(e, 'status_code'):
-                provider_error_details = {
-                    "provider": "google",
-                    "status_code": e.status_code,
-                    "error_type": error_type,
-                    "error_message": error_msg
-                }
-                print(f"❌ Gemini: Google API Error Details: {provider_error_details}")
-            elif hasattr(e, 'details'):
-                try:
-                    provider_error_details = {
-                        "provider": "google",
-                        "error_details": str(e.details),
-                        "error_type": error_type,
-                        "error_message": error_msg
-                    }
-                    print(f"❌ Gemini: Google API Error Details: {provider_error_details}")
-                except Exception as parse_error:
-                    print(f"⚠️ Gemini: Could not parse error details: {parse_error}")
-                    provider_error_details = {
-                        "provider": "google",
-                        "raw_error": error_msg,
-                        "error_type": error_type
-                    }
-            else:
-                provider_error_details = {
-                    "provider": "google",
-                    "raw_error": error_msg,
-                    "error_type": error_type
-                }
-            
             # Check for specific error types
             if "quota" in error_msg.lower() or "limit" in error_msg.lower():
                 print(f"❌ Gemini: Quota or rate limit exceeded detected")
-                raise Exception(f"MODEL_UNAVAILABLE: GEMINI15 is currently unavailable (quota/rate limit exceeded). Switching to another model. Provider details: {provider_error_details}")
+                raise Exception(f"MODEL_UNAVAILABLE: GEMINI15 is currently unavailable (quota/rate limit exceeded). Switching to another model.")
             elif "authentication" in error_msg.lower() or "invalid" in error_msg.lower() or "api_key" in error_msg.lower():
                 print(f"❌ Gemini: Authentication or API key error detected")
-                raise Exception(f"MODEL_UNAVAILABLE: GEMINI15 is currently unavailable (authentication error). Switching to another model. Provider details: {provider_error_details}")
+                raise Exception(f"MODEL_UNAVAILABLE: GEMINI15 is currently unavailable (authentication error). Switching to another model.")
             elif "timeout" in error_msg.lower() or "connection" in error_msg.lower():
                 print(f"❌ Gemini: Network timeout or connection error detected")
-                raise Exception(f"MODEL_UNAVAILABLE: GEMINI15 is currently unavailable (network error). Switching to another model. Provider details: {provider_error_details}")
+                raise Exception(f"MODEL_UNAVAILABLE: GEMINI15 is currently unavailable (network error). Switching to another model.")
             else:
                 print(f"❌ Gemini: Generic error, converting to MODEL_UNAVAILABLE")
-                raise Exception(f"MODEL_UNAVAILABLE: GEMINI15 is currently unavailable ({error_type}: {error_msg}). Switching to another model. Provider details: {provider_error_details}")
+                raise Exception(f"MODEL_UNAVAILABLE: GEMINI15 is currently unavailable ({error_type}: {error_msg}). Switching to another model.")
 
 

py_backend/app/services/gpt4v_service.py

@@ -102,41 +102,16 @@ class GPT4VService(VLMService):
             print(f"❌ GPT-4V: Error type: {error_type}")
             print(f"❌ GPT-4V: Error message: {error_msg}")
             
-            # Capture OpenAI API specific error details
-            provider_error_details = {}
-            
-            # Check for OpenAI API specific errors
-            if hasattr(e, 'response') and e.response:
-                try:
-                    error_response = e.response.json()
-                    print(f"❌ GPT-4V: OpenAI API Error Response: {error_response}")
-                    provider_error_details = {
-                        "provider": "openai",
-                        "error_code": error_response.get("error", {}).get("code"),
-                        "error_type": error_response.get("error", {}).get("type"),
-                        "error_message": error_response.get("error", {}).get("message"),
-                        "error_param": error_response.get("error", {}).get("param"),
-                        "status_code": e.response.status_code
-                    }
-                    print(f"❌ GPT-4V: Parsed Error Details: {provider_error_details}")
-                except Exception as parse_error:
-                    print(f"⚠️ GPT-4V: Could not parse error response: {parse_error}")
-                    provider_error_details = {
-                        "provider": "openai",
-                        "raw_error": error_msg,
-                        "status_code": getattr(e.response, 'status_code', None) if hasattr(e, 'response') else None
-                    }
-            
             # Check for specific error types
             if "rate_limit" in error_msg.lower() or "quota" in error_msg.lower():
                 print(f"❌ GPT-4V: Rate limit or quota exceeded detected")
-                raise Exception(f"MODEL_UNAVAILABLE: GPT-4O is currently unavailable (rate limit/quota exceeded). Switching to another model. Provider details: {provider_error_details}")
+                raise Exception(f"MODEL_UNAVAILABLE: GPT-4O is currently unavailable (rate limit/quota exceeded). Switching to another model.")
             elif "authentication" in error_msg.lower() or "invalid" in error_msg.lower() or "api_key" in error_msg.lower():
                 print(f"❌ GPT-4V: Authentication or API key error detected")
-                raise Exception(f"MODEL_UNAVAILABLE: GPT-4O is currently unavailable (authentication error). Switching to another model. Provider details: {provider_error_details}")
+                raise Exception(f"MODEL_UNAVAILABLE: GPT-4O is currently unavailable (authentication error). Switching to another model.")
             elif "timeout" in error_msg.lower() or "connection" in error_msg.lower():
                 print(f"❌ GPT-4V: Network timeout or connection error detected")
-                raise Exception(f"MODEL_UNAVAILABLE: GPT-4O is currently unavailable (network error). Switching to another model. Provider details: {provider_error_details}")
+                raise Exception(f"MODEL_UNAVAILABLE: GPT-4O is currently unavailable (network error). Switching to another model.")
             else:
                 print(f"❌ GPT-4V: Generic error, converting to MODEL_UNAVAILABLE")
-                raise Exception(f"MODEL_UNAVAILABLE: GPT-4O is currently unavailable ({error_type}: {error_msg}). Switching to another model. Provider details: {provider_error_details}") 
+                raise Exception(f"MODEL_UNAVAILABLE: GPT-4O is currently unavailable ({error_type}: {error_msg}). Switching to another model.") 

py_backend/app/services/huggingface_service.py

@@ -81,43 +81,8 @@ class HuggingFaceService(VLMService):
                 ) as resp:
                     raw_text = await resp.text()
                     if resp.status != 200:
-                        # Capture the actual error response from HuggingFace
-                        try:
-                            error_response = await resp.json()
-                            print(f"❌ HuggingFace: API Error Response (HTTP {resp.status}): {error_response}")
-                            
-                            # Extract specific error details
-                            provider_error_details = {
-                                "provider": "huggingface",
-                                "status_code": resp.status,
-                                "error_response": error_response,
-                                "model_id": self.model_id,
-                                "model_name": self.model_name
-                            }
-                            
-                            # Check for specific error types
-                            if "error" in error_response:
-                                error_info = error_response["error"]
-                                provider_error_details.update({
-                                    "error_type": error_info.get("type"),
-                                    "error_message": error_info.get("message"),
-                                    "error_code": error_info.get("code")
-                                })
-                            
-                            print(f"❌ HuggingFace: Parsed Error Details: {provider_error_details}")
-                            
-                            # Any non-200 status - throw generic error for fallback handling
-                            raise Exception(f"MODEL_UNAVAILABLE: {self.model_name} is currently unavailable (HTTP {resp.status}). Switching to another model. Provider details: {provider_error_details}")
-                        except Exception as parse_error:
-                            print(f"⚠️ HuggingFace: Could not parse error response: {parse_error}")
-                            provider_error_details = {
-                                "provider": "huggingface",
-                                "status_code": resp.status,
-                                "raw_response": raw_text,
-                                "model_id": self.model_id,
-                                "model_name": self.model_name
-                            }
-                            raise Exception(f"MODEL_UNAVAILABLE: {self.model_name} is currently unavailable (HTTP {resp.status}). Switching to another model. Provider details: {provider_error_details}")
+                        # Any non-200 status - throw generic error for fallback handling
+                        raise Exception(f"MODEL_UNAVAILABLE: {self.model_name} is currently unavailable (HTTP {resp.status}). Switching to another model.")
                     result = await resp.json()
         except Exception as e:
             if "MODEL_UNAVAILABLE" in str(e):

py_backend/app/services/vlm_service.py

@@ -66,27 +66,20 @@ class VLMServiceManager:
         """Generate caption using available VLM services with fallback"""
         print(f"🚀 VLM Manager: Starting caption generation")
         print(f"🚀 VLM Manager: Requested model: {model_name}")
-        print(f"🚀 VLM Manager: Available services: {[s.model_name for s in self.services.values()]}")
-        print(f"🚀 VLM Manager: Total services: {len(self.services)}")
         
         # Select initial service
         service = None
         if model_name:
-            print(f"🚀 VLM Manager: Looking for requested model: {model_name}")
             service = self.services.get(model_name)
-            if service:
-                print(f"🚀 VLM Manager: Found requested model: {service.model_name}")
-            else:
+            if not service:
                 print(f"⚠️ VLM Manager: Requested model {model_name} not found in services")
         
         if not service:
-            print(f"🚀 VLM Manager: No specific model requested, selecting from available services")
             if db_session:
                 try:
                     from .. import crud
                     available_models = crud.get_models(db_session)
                     available_model_codes = [m.m_code for m in available_models if m.is_available]
-                    print(f"🚀 VLM Manager: Available models from DB: {available_model_codes}")
                     
                     available_services = [s for s in self.services.values() if s.model_name in available_model_codes]
                     if available_services:
@@ -94,34 +87,22 @@ class VLMServiceManager:
                         shuffled_services = available_services.copy()
                         random.shuffle(shuffled_services)
                         service = shuffled_services[0]
-                        print(f"🚀 VLM Manager: Randomly selected service: {service.model_name} (from {len(available_services)} available)")
-                        print(f"🚀 VLM Manager: All available services were: {[s.model_name for s in available_services]}")
-                        print(f"🚀 VLM Manager: Shuffled order: {[s.model_name for s in shuffled_services]}")
                     else:
-                        print(f"⚠️ VLM Manager: No available services from DB, using fallback")
                         service = next(iter(self.services.values()))
-                        print(f"🚀 VLM Manager: Using fallback service: {service.model_name}")
                 except Exception as e:
                     print(f"❌ VLM Manager: Error checking database availability: {e}, using fallback")
                     service = next(iter(self.services.values()))
-                    print(f"🚀 VLM Manager: Using fallback service: {service.model_name}")
             else:
-                print(f"🚀 VLM Manager: No database session, using service property")
                 available_services = [s for s in self.services.values() if s.is_available]
                 if available_services:
                     import random
                     service = random.choice(available_services)
-                    print(f"🚀 VLM Manager: Randomly selected service: {service.model_name}")
                 else:
-                    print(f"⚠️ VLM Manager: No available services, using fallback")
                     service = next(iter(self.services.values()))
-                    print(f"🚀 VLM Manager: Using fallback service: {service.model_name}")
         
         if not service:
             raise ValueError("No VLM services available")
         
-        print(f"🚀 VLM Manager: Initial service selected: {service.model_name}")
-        
         # Track attempts to avoid infinite loops
         attempted_services = set()
         max_attempts = len(self.services)
@@ -129,7 +110,6 @@ class VLMServiceManager:
         while len(attempted_services) < max_attempts:
             try:
                 print(f"🚀 VLM Manager: Attempting with service: {service.model_name}")
-                print(f"🚀 VLM Manager: Attempt #{len(attempted_services) + 1}/{max_attempts}")
                 
                 result = await service.generate_caption(image_bytes, prompt, metadata_instructions)
                 if isinstance(result, dict):
@@ -150,45 +130,6 @@ class VLMServiceManager:
                 if "MODEL_UNAVAILABLE" in error_str:
                     attempted_services.add(service.model_name)
                     print(f"🔄 VLM Manager: Model {service.model_name} is unavailable, trying another service...")
-                    print(f"🔄 VLM Manager: Attempted services so far: {attempted_services}")
-                    
-                    # Extract provider error details if available
-                    provider_error_details = {}
-                    if "Provider details:" in error_str:
-                        try:
-                            # Extract the provider details section
-                            details_start = error_str.find("Provider details:") + len("Provider details:")
-                            details_str = error_str[details_start:].strip()
-                            if details_str.startswith("{") and details_str.endswith("}"):
-                                import json
-                                provider_error_details = json.loads(details_str)
-                                print(f"🔍 VLM Manager: Provider Error Details: {provider_error_details}")
-                        except Exception as parse_error:
-                            print(f"⚠️ VLM Manager: Could not parse provider error details: {parse_error}")
-                    
-                    # Log specific error information
-                    if provider_error_details:
-                        provider = provider_error_details.get("provider", "unknown")
-                        status_code = provider_error_details.get("status_code")
-                        error_type = provider_error_details.get("error_type")
-                        error_message = provider_error_details.get("error_message")
-                        
-                        print(f"🔍 VLM Manager: {service.model_name} failed with {provider} error:")
-                        print(f"   Status Code: {status_code}")
-                        print(f"   Error Type: {error_type}")
-                        print(f"   Error Message: {error_message}")
-                        
-                        # Log specific error patterns
-                        if status_code == 400:
-                            print(f"🔍 VLM Manager: HTTP 400 detected - likely request format issue")
-                        elif status_code == 401:
-                            print(f"🔍 VLM Manager: HTTP 401 detected - authentication issue")
-                        elif status_code == 403:
-                            print(f"🔍 VLM Manager: HTTP 403 detected - access forbidden")
-                        elif status_code == 429:
-                            print(f"🔍 VLM Manager: HTTP 429 detected - rate limit exceeded")
-                        elif status_code == 500:
-                            print(f"🔍 VLM Manager: HTTP 500 detected - server error")
                     
                     # Try to find another available service
                     if db_session:
@@ -196,7 +137,6 @@ class VLMServiceManager:
                             from .. import crud
                             available_models = crud.get_models(db_session)
                             available_model_codes = [m.m_code for m in available_models if m.is_available]
-                            print(f"🔄 VLM Manager: Available models from DB: {available_model_codes}")
                             
                             # Find next available service that hasn't been attempted
                             for next_service in self.services.values():
@@ -206,12 +146,10 @@ class VLMServiceManager:
                                     print(f"🔄 VLM Manager: Switching to fallback service: {service.model_name}")
                                     break
                             else:
-                                print(f"⚠️ VLM Manager: No more available services from DB, using any untried service")
                                 # No more available services, use any untried service
                                 for next_service in self.services.values():
                                     if next_service.model_name not in attempted_services:
                                         service = next_service
-                                        print(f"🔄 VLM Manager: Using untried service as fallback: {service.model_name}")
                                         break
                         except Exception as db_error:
                             print(f"❌ VLM Manager: Error checking database availability: {db_error}")
@@ -219,15 +157,12 @@ class VLMServiceManager:
                             for next_service in self.services.values():
                                 if next_service.model_name not in attempted_services:
                                     service = next_service
-                                    print(f"🔄 VLM Manager: Using untried service as fallback: {service.model_name}")
                                     break
                     else:
-                        print(f"🔄 VLM Manager: No database session, using any untried service")
                         # No database session, use any untried service
                         for next_service in self.services.values():
                             if next_service.model_name not in attempted_services:
                                 service = next_service
-                                print(f"🔄 VLM Manager: Using untried service as fallback: {service.model_name}")
                                 break
                     
                     if not service:
@@ -242,7 +177,6 @@ class VLMServiceManager:
         
         # If we get here, we've tried all services
         print(f"❌ VLM Manager: All VLM services failed due to model unavailability")
-        print(f"❌ VLM Manager: Attempted services: {attempted_services}")
         raise ValueError("All VLM services failed due to model unavailability")
 
 vlm_manager = VLMServiceManager()