Mark Cuizon commited on
Commit
88a0782
·
1 Parent(s): 3c12ca1

Simplify Gemini client path and prefer gemini-3.1

Browse files

Use the legacy google.generativeai client with a shorter model fallback list headed by gemini-3.1, and restore direct error details in fallback analysis responses.

Files changed (1) hide show
  1. utils/analysis_engine.py +19 -243
utils/analysis_engine.py CHANGED
@@ -14,14 +14,6 @@ import hashlib
14
  from functools import lru_cache
15
 
16
 
17
- try:
18
- from google import genai
19
- from google.genai import types as genai_types
20
- except ImportError:
21
- genai = None
22
- genai_types = None
23
-
24
-
25
 
26
  # LangChain imports for Google Gemini
27
  try:
@@ -2485,45 +2477,7 @@ class PromptAnalyzer:
2485
  def __init__(self):
2486
  self.logger = logging.getLogger(f"{__name__}.PromptAnalyzer")
2487
  self.ai_config = get_ai_config()
2488
- self._preferred_models = []
2489
- self._active_model = None
2490
- self._use_new_genai = False
2491
  self._initialize_llm()
2492
-
2493
- def _is_blocked_model(self, model_name: str) -> bool:
2494
- """Return True for model IDs known to fail in current API paths."""
2495
- if not model_name:
2496
- return True
2497
- blocked_prefixes = [
2498
- 'gemini-3.1',
2499
- 'gemini-pro-vision',
2500
- ]
2501
- model_name = str(model_name).strip().lower()
2502
- return any(model_name.startswith(prefix) for prefix in blocked_prefixes)
2503
-
2504
- def _normalize_requested_model(self, model_name: Optional[str]) -> Optional[str]:
2505
- """Normalize requested model and remap unsupported variants to supported defaults."""
2506
- if not model_name:
2507
- return None
2508
- candidate = str(model_name).strip()
2509
- if self._is_blocked_model(candidate):
2510
- self.logger.warning(f"Requested model '{candidate}' is blocked; remapping to gemini-2.5-pro")
2511
- return 'gemini-2.5-pro'
2512
- return candidate
2513
-
2514
- def _format_llm_error_for_user(self, err: Exception) -> str:
2515
- """Create a safe, concise user-facing LLM error message."""
2516
- if self._is_model_not_found_error(err):
2517
- return "Model endpoint unavailable; fallback analysis was used"
2518
-
2519
- err_str = str(err).lower()
2520
- if any(k in err_str for k in ["429", "quota", "resource_exhausted", "rate"]):
2521
- return "Rate limit reached; fallback analysis was used"
2522
-
2523
- if "timeout" in err_str:
2524
- return "LLM request timed out; fallback analysis was used"
2525
-
2526
- return "LLM request failed; fallback analysis was used"
2527
 
2528
  def _get_current_language(self) -> str:
2529
  """Get current language from session state for multilingual analysis"""
@@ -2598,7 +2552,6 @@ class PromptAnalyzer:
2598
  def _initialize_llm(self):
2599
  """Initialize the LLM with Google Gemini configuration"""
2600
  try:
2601
- self._use_new_genai = False
2602
  # Get Google API key from environment variables or Streamlit secrets
2603
  google_api_key = None
2604
 
@@ -2624,26 +2577,18 @@ class PromptAnalyzer:
2624
  self.llm = None
2625
  return
2626
 
2627
- # Model fallback list ordered by current API compatibility and quality.
2628
- # Keep older IDs at the end for environments pinned to legacy SDKs.
2629
- default_models = [
 
 
 
2630
  'gemini-2.5-pro',
2631
- 'gemini-2.5-flash',
2632
- 'gemini-1.5-pro',
2633
  'gemini-1.5-pro-002',
2634
- 'gemini-1.5-flash',
2635
- 'gemini-1.5-flash-002',
2636
  'gemini-1.0-pro'
2637
  ]
2638
- configured_model = self._normalize_requested_model(getattr(self.ai_config, 'model', None))
2639
- if configured_model and configured_model not in default_models:
2640
- default_models.insert(0, configured_model)
2641
- elif configured_model:
2642
- default_models = [configured_model] + [m for m in default_models if m != configured_model]
2643
- default_models = [m for m in default_models if not self._is_blocked_model(m)]
2644
- preferred_models = self._preferred_models[:] if self._preferred_models else default_models
2645
- preferred_models = [m for m in preferred_models if not self._is_blocked_model(m)]
2646
- self._preferred_models = preferred_models[:]
2647
 
2648
  # Use optimal settings from memory: temperature=0.0 for maximum accuracy [[memory:7795938]]
2649
  temperature = 0.0
@@ -2658,54 +2603,12 @@ class PromptAnalyzer:
2658
  try:
2659
  if google_api_key:
2660
  os.environ["GOOGLE_API_KEY"] = google_api_key
2661
- os.environ["GOOGLE_AI_API_KEY"] = google_api_key
2662
  except Exception:
2663
  pass
2664
 
2665
- # Prefer the latest Gemini SDK (google.genai) to avoid deprecated client issues.
2666
- runtime_models = preferred_models[:]
2667
- if genai is not None:
2668
- try:
2669
- client = genai.Client(api_key=google_api_key)
2670
- discovered_models = []
2671
- for m in client.models.list():
2672
- name = getattr(m, 'name', '') or ''
2673
- if name.startswith('models/'):
2674
- name = name.replace('models/', '', 1)
2675
-
2676
- supported = (
2677
- getattr(m, 'supported_actions', None)
2678
- or getattr(m, 'supported_generation_methods', None)
2679
- or []
2680
- )
2681
- supported_text = ' '.join([str(x) for x in supported]).lower()
2682
- if name and (not supported or 'generate' in supported_text or 'content' in supported_text):
2683
- discovered_models.append(name)
2684
- discovered_models = [m for m in discovered_models if not self._is_blocked_model(m)]
2685
-
2686
- if discovered_models:
2687
- prioritized = [m for m in preferred_models if m in discovered_models]
2688
- discovered_extras = [m for m in discovered_models if m not in prioritized]
2689
- runtime_models = prioritized + discovered_extras
2690
- self._preferred_models = runtime_models[:]
2691
- self.logger.info(f"Discovered {len(discovered_models)} Gemini models via google.genai")
2692
-
2693
- # google.genai client does not require model construction upfront.
2694
- self.llm = client
2695
- self._use_new_genai = True
2696
- self._temperature = temperature
2697
- self._max_tokens = max_tokens
2698
- self._active_model = runtime_models[0] if runtime_models else preferred_models[0]
2699
- self.logger.info(f"✅ Configured Gemini client (google.genai) with model: {self._active_model}")
2700
- self.logger.info(f"LLM configured with max_tokens={max_tokens}, temperature={temperature}")
2701
- return
2702
- except Exception as discovery_error:
2703
- self.logger.warning(f"google.genai initialization failed, falling back to legacy client: {discovery_error}")
2704
- self.llm = None
2705
-
2706
- # Fallback: legacy google.generativeai client (kept for compatibility).
2707
  init_error = None
2708
- for mdl in runtime_models:
2709
  try:
2710
  import google.generativeai as genai
2711
  genai.configure(api_key=google_api_key)
@@ -2738,7 +2641,6 @@ class PromptAnalyzer:
2738
  self._temperature = temperature
2739
  self._max_tokens = max_tokens
2740
  self._safety_settings = safety_settings
2741
- self._active_model = mdl
2742
  model = mdl
2743
  init_error = None
2744
  self.logger.info(f"✅ Configured Gemini model {mdl} with permissive safety settings for agricultural analysis")
@@ -2756,54 +2658,6 @@ class PromptAnalyzer:
2756
  except Exception as e:
2757
  self.logger.error(f"Error initializing LLM: {str(e)}")
2758
  self.llm = None
2759
-
2760
- def _is_model_not_found_error(self, err: Exception) -> bool:
2761
- """Detect provider not-found model errors that should trigger model fallback."""
2762
- err_str = str(err).lower()
2763
- return (
2764
- "404" in err_str
2765
- and "model" in err_str
2766
- and ("not found" in err_str or "not supported" in err_str)
2767
- )
2768
-
2769
- def _switch_to_next_model(self) -> bool:
2770
- """Reinitialize LLM preferring the next configured Gemini model."""
2771
- if not self._preferred_models:
2772
- return False
2773
-
2774
- active = self._active_model
2775
- if active in self._preferred_models:
2776
- idx = self._preferred_models.index(active)
2777
- # Rotate so next candidates are attempted first on reinit.
2778
- self._preferred_models = self._preferred_models[idx + 1:] + self._preferred_models[:idx + 1]
2779
-
2780
- # Reinitialize and succeed only if a different active model is selected.
2781
- previous = active
2782
- self._initialize_llm()
2783
- return bool(self.llm) and self._active_model is not None and self._active_model != previous
2784
-
2785
- def _extract_new_genai_text(self, response: Any) -> str:
2786
- """Extract text from google.genai response objects in a schema-tolerant way."""
2787
- if response is None:
2788
- return ""
2789
-
2790
- direct_text = getattr(response, 'text', None)
2791
- if isinstance(direct_text, str) and direct_text.strip():
2792
- return direct_text.strip()
2793
-
2794
- candidates = getattr(response, 'candidates', None) or []
2795
- for cand in candidates:
2796
- content = getattr(cand, 'content', None)
2797
- parts = getattr(content, 'parts', None) or []
2798
- chunks = []
2799
- for part in parts:
2800
- txt = getattr(part, 'text', None)
2801
- if isinstance(txt, str) and txt:
2802
- chunks.append(txt)
2803
- if chunks:
2804
- return "".join(chunks).strip()
2805
-
2806
- return ""
2807
 
2808
  def ensure_llm_available(self):
2809
  """Ensure LLM is available, reinitialize if necessary"""
@@ -3285,57 +3139,7 @@ class PromptAnalyzer:
3285
  last_err = None
3286
  for attempt in range(1, (getattr(self.ai_config, 'retry_attempts', 3) or 3) + 1):
3287
  try:
3288
- if getattr(self, '_use_new_genai', False):
3289
- combined_prompt = f"{system_prompt}\n\n{human_prompt}"
3290
- response_text = ""
3291
-
3292
- if genai_types is not None:
3293
- config = genai_types.GenerateContentConfig(
3294
- temperature=self._temperature,
3295
- max_output_tokens=self._max_tokens,
3296
- )
3297
- else:
3298
- config = {
3299
- "temperature": self._temperature,
3300
- "max_output_tokens": self._max_tokens,
3301
- }
3302
-
3303
- stream = self.llm.models.generate_content_stream(
3304
- model=self._active_model,
3305
- contents=combined_prompt,
3306
- config=config,
3307
- )
3308
- for chunk in stream:
3309
- chunk_text = getattr(chunk, 'text', None) or ''
3310
- if chunk_text:
3311
- response_text += chunk_text
3312
- if progress_callback and hasattr(progress_callback, 'on_stream_chunk'):
3313
- try:
3314
- progress_callback.on_stream_chunk(
3315
- int(step['number']),
3316
- len(response_text),
3317
- )
3318
- except Exception:
3319
- pass
3320
-
3321
- # Fallback to non-streaming if stream yields empty text.
3322
- if not response_text.strip():
3323
- one_shot = self.llm.models.generate_content(
3324
- model=self._active_model,
3325
- contents=combined_prompt,
3326
- config=config,
3327
- )
3328
- response_text = self._extract_new_genai_text(one_shot)
3329
-
3330
- class GeminiResponse:
3331
- def __init__(self, content):
3332
- self.content = content
3333
-
3334
- if not response_text.strip():
3335
- raise Exception("Empty response from Gemini API (google.genai)")
3336
-
3337
- response = GeminiResponse(response_text)
3338
- elif hasattr(self, '_use_direct_gemini') and self._use_direct_gemini:
3339
  # Use direct Gemini API with streaming to keep HF websocket alive
3340
  import google.generativeai as genai
3341
  combined_prompt = f"{system_prompt}\n\n{human_prompt}"
@@ -3397,14 +3201,6 @@ class PromptAnalyzer:
3397
  except Exception as e:
3398
  last_err = e
3399
  err_str = str(e).lower()
3400
- if self._is_model_not_found_error(e):
3401
- self.logger.warning(
3402
- f"Model {self._active_model} not available for generate_content. "
3403
- "Attempting fallback model..."
3404
- )
3405
- if self._switch_to_next_model():
3406
- continue
3407
- raise
3408
  # Backoff on rate/quota errors, otherwise fail fast
3409
  if any(k in err_str for k in ["429", "quota", "insufficient_quota", "quota_exceeded", "resource_exhausted"]):
3410
  sleep_s = min(2 ** attempt, 8)
@@ -3656,7 +3452,7 @@ class PromptAnalyzer:
3656
  'parameter_comparisons': [],
3657
  'success': True,
3658
  'processing_time': 0.1,
3659
- 'error_details': self._format_llm_error_for_user(error)
3660
  }
3661
  except Exception as fallback_error:
3662
  self.logger.error(f"Error creating fallback result: {fallback_error}")
@@ -3671,7 +3467,7 @@ class PromptAnalyzer:
3671
  'parameter_comparisons': [],
3672
  'success': False,
3673
  'processing_time': 0.1,
3674
- 'error_details': "Fallback processing encountered multiple errors"
3675
  }
3676
 
3677
  def _sanitize_json_string(self, json_str: str) -> str:
@@ -3973,28 +3769,9 @@ class PromptAnalyzer:
3973
  )
3974
 
3975
  try:
3976
- if getattr(self, '_use_new_genai', False):
3977
- if genai_types is not None:
3978
- config = genai_types.GenerateContentConfig(
3979
- temperature=self._temperature,
3980
- max_output_tokens=min(self._max_tokens, 4096),
3981
- )
3982
- else:
3983
- config = {
3984
- "temperature": self._temperature,
3985
- "max_output_tokens": min(self._max_tokens, 4096),
3986
- }
3987
-
3988
- response = self.llm.models.generate_content(
3989
- model=self._active_model,
3990
- contents=prompt,
3991
- config=config,
3992
- )
3993
- text = self._extract_new_genai_text(response)
3994
- else:
3995
- import google.generativeai as genai # noqa: F401 (ensures client is available)
3996
- response = self.llm.generate_content(prompt) # type: ignore[attr-defined]
3997
- text = getattr(response, 'text', None)
3998
  except Exception as gen_err:
3999
  self.logger.error(f"Gemini generate_content failed: {gen_err}")
4000
  return None
@@ -8631,11 +8408,10 @@ class AnalysisEngine:
8631
  ]
8632
 
8633
  # Combine detailed analysis
8634
- user_error_note = self._format_llm_error_for_user(error)
8635
  if detailed_analysis_parts:
8636
- detailed_analysis = "\n".join(detailed_analysis_parts) + f"\n\nNote: This analysis was generated using fallback processing due to LLM unavailability. {user_error_note}."
8637
  else:
8638
- detailed_analysis = f"Due to LLM unavailability, this step has been processed using enhanced fallback methods. {user_error_note}."
8639
 
8640
  return {
8641
  'step_number': step.get('number', 0),
@@ -8646,7 +8422,7 @@ class AnalysisEngine:
8646
  'data_quality': 'Standard (Fallback Mode)',
8647
  'confidence_level': 'Medium',
8648
  'fallback_mode': True,
8649
- 'error_details': user_error_note,
8650
  'processing_method': 'enhanced_fallback_with_averages',
8651
  'soil_averages_used': soil_averages,
8652
  'leaf_averages_used': leaf_averages
 
14
  from functools import lru_cache
15
 
16
 
 
 
 
 
 
 
 
 
17
 
18
  # LangChain imports for Google Gemini
19
  try:
 
2477
  def __init__(self):
2478
  self.logger = logging.getLogger(f"{__name__}.PromptAnalyzer")
2479
  self.ai_config = get_ai_config()
 
 
 
2480
  self._initialize_llm()
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2481
 
2482
  def _get_current_language(self) -> str:
2483
  """Get current language from session state for multilingual analysis"""
 
2552
  def _initialize_llm(self):
2553
  """Initialize the LLM with Google Gemini configuration"""
2554
  try:
 
2555
  # Get Google API key from environment variables or Streamlit secrets
2556
  google_api_key = None
2557
 
 
2577
  self.llm = None
2578
  return
2579
 
2580
+ # Use optimal Gemini 3.1 configuration for maximum performance
2581
+ configured_model = 'gemini-3.1' # Force use of best available model
2582
+
2583
+ # Final model fallback list to avoid NotFound errors on older SDKs
2584
+ preferred_models = [
2585
+ 'gemini-3.1',
2586
  'gemini-2.5-pro',
 
 
2587
  'gemini-1.5-pro-002',
2588
+ 'gemini-1.5-pro-latest',
2589
+ 'gemini-1.5-pro',
2590
  'gemini-1.0-pro'
2591
  ]
 
 
 
 
 
 
 
 
 
2592
 
2593
  # Use optimal settings from memory: temperature=0.0 for maximum accuracy [[memory:7795938]]
2594
  temperature = 0.0
 
2603
  try:
2604
  if google_api_key:
2605
  os.environ["GOOGLE_API_KEY"] = google_api_key
 
2606
  except Exception:
2607
  pass
2608
 
2609
+ # Force direct Google Generative AI client to avoid any ADC/metadata usage
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2610
  init_error = None
2611
+ for mdl in preferred_models:
2612
  try:
2613
  import google.generativeai as genai
2614
  genai.configure(api_key=google_api_key)
 
2641
  self._temperature = temperature
2642
  self._max_tokens = max_tokens
2643
  self._safety_settings = safety_settings
 
2644
  model = mdl
2645
  init_error = None
2646
  self.logger.info(f"✅ Configured Gemini model {mdl} with permissive safety settings for agricultural analysis")
 
2658
  except Exception as e:
2659
  self.logger.error(f"Error initializing LLM: {str(e)}")
2660
  self.llm = None
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2661
 
2662
  def ensure_llm_available(self):
2663
  """Ensure LLM is available, reinitialize if necessary"""
 
3139
  last_err = None
3140
  for attempt in range(1, (getattr(self.ai_config, 'retry_attempts', 3) or 3) + 1):
3141
  try:
3142
+ if hasattr(self, '_use_direct_gemini') and self._use_direct_gemini:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3143
  # Use direct Gemini API with streaming to keep HF websocket alive
3144
  import google.generativeai as genai
3145
  combined_prompt = f"{system_prompt}\n\n{human_prompt}"
 
3201
  except Exception as e:
3202
  last_err = e
3203
  err_str = str(e).lower()
 
 
 
 
 
 
 
 
3204
  # Backoff on rate/quota errors, otherwise fail fast
3205
  if any(k in err_str for k in ["429", "quota", "insufficient_quota", "quota_exceeded", "resource_exhausted"]):
3206
  sleep_s = min(2 ** attempt, 8)
 
3452
  'parameter_comparisons': [],
3453
  'success': True,
3454
  'processing_time': 0.1,
3455
+ 'error_details': f"LLM processing failed: {str(error)}"
3456
  }
3457
  except Exception as fallback_error:
3458
  self.logger.error(f"Error creating fallback result: {fallback_error}")
 
3467
  'parameter_comparisons': [],
3468
  'success': False,
3469
  'processing_time': 0.1,
3470
+ 'error_details': f"Multiple errors: LLM={str(error)}, Fallback={str(fallback_error)}"
3471
  }
3472
 
3473
  def _sanitize_json_string(self, json_str: str) -> str:
 
3769
  )
3770
 
3771
  try:
3772
+ import google.generativeai as genai # noqa: F401 (ensures client is available)
3773
+ response = self.llm.generate_content(prompt) # type: ignore[attr-defined]
3774
+ text = getattr(response, 'text', None)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3775
  except Exception as gen_err:
3776
  self.logger.error(f"Gemini generate_content failed: {gen_err}")
3777
  return None
 
8408
  ]
8409
 
8410
  # Combine detailed analysis
 
8411
  if detailed_analysis_parts:
8412
+ detailed_analysis = "\n".join(detailed_analysis_parts) + f"\n\nNote: This analysis was generated using fallback processing due to LLM unavailability. Error: {str(error)}"
8413
  else:
8414
+ detailed_analysis = f"Due to LLM unavailability, this step has been processed using enhanced fallback methods. Error: {str(error)}"
8415
 
8416
  return {
8417
  'step_number': step.get('number', 0),
 
8422
  'data_quality': 'Standard (Fallback Mode)',
8423
  'confidence_level': 'Medium',
8424
  'fallback_mode': True,
8425
+ 'error_details': str(error),
8426
  'processing_method': 'enhanced_fallback_with_averages',
8427
  'soil_averages_used': soil_averages,
8428
  'leaf_averages_used': leaf_averages