added safety score. added proxy

app/api_helpers.py

@@ -2,27 +2,20 @@ import json
 import time
 import math
 import asyncio
-import base64
-import random 
 from typing import List, Dict, Any, Callable, Union, Optional
 
 from fastapi.responses import JSONResponse, StreamingResponse
 from google.auth.transport.requests import Request as AuthRequest
 from google.genai import types
-from google.genai.types import GenerateContentResponse 
-from google import genai
 from openai import AsyncOpenAI 
-from openai.types.chat import ChatCompletionMessage, ChatCompletionMessageToolCall
-from openai.types.chat.chat_completion_chunk import ChoiceDeltaToolCall, ChoiceDeltaToolCallFunction
+
 
 from models import OpenAIRequest, OpenAIMessage
 from message_processing import (
-    deobfuscate_text,
     convert_to_openai_format, 
     convert_chunk_to_openai,
-    create_final_chunk,
-    parse_gemini_response_for_reasoning_and_content, 
-    extract_reasoning_by_tags
+    extract_reasoning_by_tags,
+    _create_safety_ratings_html
 )
 import config as app_config
 from config import VERTEX_REASONING_TAG
@@ -123,12 +116,13 @@ def create_generation_config(request: OpenAIRequest) -> Dict[str, Any]:
     if request.seed is not None: config["seed"] = request.seed
     if request.n is not None: config["candidate_count"] = request.n
     
+    safety_threshold = "BLOCK_NONE" if app_config.SAFETY_SCORE else "BLOCK_ONLY_HIGH"
     config["safety_settings"] = [
-            types.SafetySetting(category="HARM_CATEGORY_HATE_SPEECH", threshold="OFF"),
-            types.SafetySetting(category="HARM_CATEGORY_DANGEROUS_CONTENT", threshold="OFF"),
-            types.SafetySetting(category="HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold="OFF"),
-            types.SafetySetting(category="HARM_CATEGORY_HARASSMENT", threshold="OFF"),
-            types.SafetySetting(category="HARM_CATEGORY_CIVIC_INTEGRITY", threshold="OFF")
+            types.SafetySetting(category="HARM_CATEGORY_HATE_SPEECH", threshold=safety_threshold),
+            types.SafetySetting(category="HARM_CATEGORY_DANGEROUS_CONTENT", threshold=safety_threshold),
+            types.SafetySetting(category="HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold=safety_threshold),
+            types.SafetySetting(category="HARM_CATEGORY_HARASSMENT", threshold=safety_threshold),
+            types.SafetySetting(category="HARM_CATEGORY_CIVIC_INTEGRITY", threshold=safety_threshold)
     ]
     # config["thinking_config"] = {"include_thoughts": True}
 
@@ -355,18 +349,29 @@ async def openai_fake_stream_generator(
         raw_response_obj = await api_call_task 
         openai_response_dict = raw_response_obj.model_dump(exclude_unset=True, exclude_none=True)
 
+        if app_config.SAFETY_SCORE and hasattr(raw_response_obj, "choices") and raw_response_obj.choices:
+            for i, choice_obj in enumerate(raw_response_obj.choices):
+                if hasattr(choice_obj, "safety_ratings") and choice_obj.safety_ratings:
+                    safety_html = _create_safety_ratings_html(choice_obj.safety_ratings)
+                    if i < len(openai_response_dict.get("choices", [])):
+                        choice_dict = openai_response_dict["choices"][i]
+                        message_dict = choice_dict.get("message")
+                        if message_dict:
+                            current_content = message_dict.get("content") or ""
+                            message_dict["content"] = current_content + safety_html
+
         if openai_response_dict.get("choices") and \
            isinstance(openai_response_dict["choices"], list) and \
            len(openai_response_dict["choices"]) > 0:
             
-            first_choice_dict_item = openai_response_dict["choices"] 
-            if first_choice_dict_item and isinstance(first_choice_dict_item, dict) : 
-                choice_message_ref = first_choice_dict_item.get("message", {}) 
+            first_choice_dict_item = openai_response_dict["choices"]
+            if first_choice_dict_item and isinstance(first_choice_dict_item, dict) :
+                choice_message_ref = first_choice_dict_item.get("message", {})
                 original_content = choice_message_ref.get("content")
                 if isinstance(original_content, str):
                     reasoning_text, actual_content = extract_reasoning_by_tags(original_content, VERTEX_REASONING_TAG)
                     choice_message_ref["content"] = actual_content
-                    if reasoning_text: 
+                    if reasoning_text:
                         choice_message_ref["reasoning_content"] = reasoning_text
         
         async for chunk_sse in _chunk_openai_response_dict_for_sse(

app/config.py

@@ -36,4 +36,11 @@ VERTEX_REASONING_TAG = "vertex_think_tag"
 # Round-robin credential selection strategy
 ROUNDROBIN = os.environ.get("ROUNDROBIN", "false").lower() == "true"
 
-# Validation logic moved to app/auth.py
+# Safety score display setting
+SAFETY_SCORE = os.environ.get("SAFETY_SCORE", "false").lower() == "true"
+# Validation logic moved to app/auth.py
+
+# Proxy settings
+HTTPS_PROXY = os.environ.get("HTTPS_PROXY")
+SOCKS_PROXY = os.environ.get("SOCKS_PROXY")
+SSL_CERT_FILE = os.environ.get("SSL_CERT_FILE")

app/main.py

@@ -1,9 +1,5 @@
 from fastapi import FastAPI, Depends # Depends might be used by root endpoint
-# from fastapi.responses import JSONResponse # Not used
 from fastapi.middleware.cors import CORSMiddleware
-# import asyncio # Not used
-# import os # Not used
-
 
 # Local module imports
 from auth import get_api_key # Potentially for root endpoint
@@ -15,8 +11,6 @@ from vertex_ai_init import init_vertex_ai
 from routes import models_api
 from routes import chat_api
 
-# import config as app_config # Not directly used in main.py
-
 app = FastAPI(title="OpenAI to Gemini Adapter")
 
 app.add_middleware(

app/message_processing.py

@@ -4,7 +4,8 @@ import json
 import time
 import random # For more unique tool_call_id
 import urllib.parse
-from typing import List, Dict, Any, Union, Literal, Tuple
+from typing import List, Dict, Any, Tuple
+from app import config as app_config
 
 from google.genai import types
 from models import OpenAIMessage, ContentPartText, ContentPartImage
@@ -292,6 +293,56 @@ def create_encrypted_full_gemini_prompt(messages: List[OpenAIMessage]) -> List[t
     return create_encrypted_gemini_prompt(processed_messages)
 
 
+def _create_safety_ratings_html(safety_ratings: list) -> str:
+    """Generates a styled HTML block for safety ratings."""
+    if not safety_ratings:
+        return ""
+
+    # Find the rating with the highest probability score
+    highest_rating = max(safety_ratings, key=lambda r: r.probability_score)
+    highest_score = highest_rating.probability_score
+
+    # Determine color based on the highest score
+    if highest_score <= 0.33:
+        color = "#0f8"  # green
+    elif highest_score <= 0.66:
+        color = "yellow"
+    else:
+        color = "#bf555d"
+
+    # Format the summary line for the highest score
+    summary_category = highest_rating.category.name.replace('HARM_CATEGORY_', '').replace('_', ' ').title()
+    summary_probability = highest_rating.probability.name
+    # Using .7f for score and .8f for severity as per example's precision
+    summary_score_str = f"{highest_rating.probability_score:.7f}" if highest_rating.probability_score is not None else "None"
+    summary_severity_str = f"{highest_rating.severity_score:.8f}" if highest_rating.severity_score is not None else "None"
+    summary_line = f"{summary_category}: {summary_probability} (Score: {summary_score_str}, Severity: {summary_severity_str})"
+
+    # Format the list of all ratings for the <pre> block
+    ratings_list = []
+    for rating in safety_ratings:
+        category = rating.category.name.replace('HARM_CATEGORY_', '').replace('_', ' ').title()
+        probability = rating.probability.name
+        score_str = f"{rating.probability_score:.7f}" if rating.probability_score is not None else "None"
+        severity_str = f"{rating.severity_score:.8f}" if rating.severity_score is not None else "None"
+        ratings_list.append(f"{category}: {probability} (Score: {score_str}, Severity: {severity_str})")
+    all_ratings_str = '\n'.join(ratings_list)
+
+    # CSS Style as specified
+    css_style = "<style>.cb{border:1px solid #444;margin:10px;border-radius:4px;background:#111}.cb summary{padding:8px;cursor:pointer;background:#222}.cb pre{margin:0;padding:10px;border-top:1px solid #444;white-space:pre-wrap}</style>"
+
+    # Final HTML structure
+    html_output = (
+        f'{css_style}'
+        f'<details class="cb">'
+        f'<summary style="color:{color}">{summary_line} ▼</summary>'
+        f'<pre>\\n--- Safety Ratings ---\\n{all_ratings_str}\\n</pre>'
+        f'</details>'
+    )
+
+    return html_output
+
+
 def deobfuscate_text(text: str) -> str:
     if not text: return text
     placeholder = "___TRIPLE_BACKTICK_PLACEHOLDER___"
@@ -385,6 +436,13 @@ def process_gemini_response_to_openai_dict(gemini_response_obj: Any, request_mod
                     reasoning_str = deobfuscate_text(reasoning_str)
                     normal_content_str = deobfuscate_text(normal_content_str)
                 
+                if app_config.SAFETY_SCORE and hasattr(candidate, 'safety_ratings') and candidate.safety_ratings:
+                    safety_html = _create_safety_ratings_html(candidate.safety_ratings)
+                    if reasoning_str:
+                        reasoning_str += safety_html
+                    else:
+                        normal_content_str += safety_html
+                
                 message_payload["content"] = normal_content_str
                 if reasoning_str:
                     message_payload['reasoning_content'] = reasoning_str
@@ -482,6 +540,13 @@ def convert_chunk_to_openai(chunk: Any, model_name: str, response_id: str, candi
                 reasoning_text = deobfuscate_text(reasoning_text)
                 normal_text = deobfuscate_text(normal_text)
 
+            if app_config.SAFETY_SCORE and hasattr(candidate, 'safety_ratings') and candidate.safety_ratings:
+                safety_html = _create_safety_ratings_html(candidate.safety_ratings)
+                if reasoning_text:
+                    reasoning_text += safety_html
+                else:
+                    normal_text += safety_html
+
             if reasoning_text: delta_payload['reasoning_content'] = reasoning_text
             if normal_text: # Only add content if it's non-empty
                 delta_payload['content'] = normal_text

app/openai_handler.py

@@ -4,13 +4,11 @@ This module encapsulates all OpenAI-specific logic that was previously in chat_a
 """
 import json
 import time
-import asyncio
 import httpx
-from typing import Dict, Any, AsyncGenerator, Optional
+from typing import Dict, Any, AsyncGenerator
 
 from fastapi.responses import JSONResponse, StreamingResponse
 import openai
-from google.auth.transport.requests import Request as AuthRequest
 
 from models import OpenAIRequest
 from config import VERTEX_REASONING_TAG
@@ -82,7 +80,11 @@ class ExpressClientWrapper:
         if 'extra_body' in payload:
             payload.update(payload.pop('extra_body'))
 
-        async with httpx.AsyncClient(timeout=300) as client:
+        proxy = app_config.SOCKS_PROXY or app_config.HTTPS_PROXY
+        client_args = {'timeout': 300, 'proxies': proxy}
+        if app_config.SSL_CERT_FILE:
+            client_args['verify'] = app_config.SSL_CERT_FILE
+        async with httpx.AsyncClient(**client_args) as client:
             async with client.stream("POST", endpoint, headers=headers, params=params, json=payload, timeout=None) as response:
                 response.raise_for_status()
                 async for chunk in self._stream_generator(response):
@@ -108,7 +110,11 @@ class ExpressClientWrapper:
         if 'extra_body' in payload:
             payload.update(payload.pop('extra_body'))
 
-        async with httpx.AsyncClient(timeout=300) as client:
+        proxy = app_config.SOCKS_PROXY or app_config.HTTPS_PROXY
+        client_args = {'timeout': 300, 'proxies': proxy}
+        if app_config.SSL_CERT_FILE:
+            client_args['verify'] = app_config.SSL_CERT_FILE
+        async with httpx.AsyncClient(**client_args) as client:
             response = await client.post(endpoint, headers=headers, params=params, json=payload, timeout=None)
             response.raise_for_status()
             return FakeChatCompletion(response.json())
@@ -120,12 +126,13 @@ class OpenAIDirectHandler:
     def __init__(self, credential_manager=None, express_key_manager=None):
         self.credential_manager = credential_manager
         self.express_key_manager = express_key_manager
+        safety_threshold = "BLOCK_NONE" if app_config.SAFETY_SCORE else "OFF"
         self.safety_settings = [
-            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "OFF"},
-            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "OFF"},
-            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "OFF"},
-            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "OFF"},
-            {"category": 'HARM_CATEGORY_CIVIC_INTEGRITY', "threshold": 'OFF'}
+            {"category": "HARM_CATEGORY_HARASSMENT", "threshold": safety_threshold},
+            {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": safety_threshold},
+            {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": safety_threshold},
+            {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": safety_threshold},
+            {"category": 'HARM_CATEGORY_CIVIC_INTEGRITY', "threshold": safety_threshold}
         ]
 
     def create_openai_client(self, project_id: str, gcp_token: str, location: str = "global") -> openai.AsyncOpenAI:
@@ -135,9 +142,18 @@ class OpenAIDirectHandler:
             f"projects/{project_id}/locations/{location}/endpoints/openapi"
         )
         
+        proxy = app_config.SOCKS_PROXY or app_config.HTTPS_PROXY
+        client_args = {}
+        if proxy:
+            client_args['proxies'] = proxy
+        if app_config.SSL_CERT_FILE:
+            client_args['verify'] = app_config.SSL_CERT_FILE
+        
+        http_client = httpx.AsyncClient(**client_args) if client_args else None
         return openai.AsyncOpenAI(
             base_url=endpoint_url,
             api_key=gcp_token,  # OAuth token
+            http_client=http_client,
         )
     
     def prepare_openai_params(self, request: OpenAIRequest, model_id: str, is_openai_search: bool = False) -> Dict[str, Any]:

app/project_id_discovery.py

@@ -2,11 +2,21 @@ import aiohttp
 import json
 import re
 from typing import Dict, Optional
+from app import config
 
 # Global cache for project IDs: {api_key: project_id}
 PROJECT_ID_CACHE: Dict[str, str] = {}
 
 
+def _get_proxy_url() -> Optional[str]:
+    """Get proxy URL from config."""
+    if config.SOCKS_PROXY:
+        return config.SOCKS_PROXY
+    if config.HTTPS_PROXY:
+        return config.HTTPS_PROXY
+    return None
+
+
 async def discover_project_id(api_key: str) -> str:
     """
     Discover project ID by triggering an intentional error with a non-existent model.
@@ -34,9 +44,10 @@ async def discover_project_id(api_key: str) -> str:
         "contents": [{"role": "user", "parts": [{"text": "test"}]}]
     }
     
+    proxy = _get_proxy_url()
     async with aiohttp.ClientSession() as session:
         try:
-            async with session.post(error_url, json=payload) as response:
+            async with session.post(error_url, json=payload, proxy=proxy, ssl=getattr(config, "SSL_CERT_FILE", None)) as response:
                 response_text = await response.text()
                 
                 try:

app/requirements.txt

@@ -4,7 +4,7 @@ google-auth==2.38.0
 google-cloud-aiplatform==1.86.0
 pydantic==2.6.1
 google-genai==1.17.0
-httpx>=0.25.0
+httpx[socks]>=0.25.0
 openai
 google-auth-oauthlib
 aiohttp

app/routes/chat_api.py

@@ -1,6 +1,5 @@
 import asyncio
 import json
-import random
 from fastapi import APIRouter, Depends, Request
 from fastapi.responses import JSONResponse, StreamingResponse
 
@@ -11,7 +10,6 @@ from google import genai
 # Local module imports
 from models import OpenAIRequest
 from auth import get_api_key
-import config as app_config
 from message_processing import (
     create_gemini_prompt,
     create_encrypted_gemini_prompt,

app/routes/models_api.py

@@ -3,7 +3,6 @@ from fastapi import APIRouter, Depends, Request
 from typing import List, Dict, Any, Set
 from auth import get_api_key
 from model_loader import get_vertex_models, get_vertex_express_models, refresh_models_config_cache
-import config as app_config
 from credentials_manager import CredentialManager
 
 router = APIRouter()

app/vertex_ai_init.py

@@ -1,8 +1,8 @@
 import json
-import asyncio # Added for await
 from google import genai
 from credentials_manager import CredentialManager, parse_multiple_json_credentials
 import config as app_config
+from google.generativeai.client import types
 from model_loader import refresh_models_config_cache # Import new model loader function
 
 # VERTEX_EXPRESS_MODELS list is now dynamically loaded via model_loader
@@ -11,6 +11,16 @@ from model_loader import refresh_models_config_cache # Import new model loader f
 
 # Global 'client' and 'get_vertex_client()' are removed.
 
+def _get_http_options() -> Optional[types.HttpOptions]:
+    """Get http options from config."""
+    if app_config.SOCKS_PROXY:
+        return types.HttpOptions(
+            client_args={'proxy': app_config.SOCKS_PROXY},
+            async_client_args={'proxy': app_config.SOCKS_PROXY},
+        )
+    return None
+
+
 async def init_vertex_ai(credential_manager_instance: CredentialManager) -> bool: # Made async
     """
     Initializes the credential manager with credentials from GOOGLE_CREDENTIALS_JSON (if provided)
@@ -85,7 +95,11 @@ async def init_vertex_ai(credential_manager_instance: CredentialManager) -> bool
             temp_creds_val, temp_project_id_val = credential_manager_instance.get_credentials()
             if temp_creds_val and temp_project_id_val:
                 try:
-                    _ = genai.Client(vertexai=True, credentials=temp_creds_val, project=temp_project_id_val, location="global")
+                    http_options = _get_http_options()
+                    if http_options:
+                        _ = genai.Client(vertexai=True, credentials=temp_creds_val, project=temp_project_id_val, location="global", http_options=http_options)
+                    else:
+                        _ = genai.Client(vertexai=True, credentials=temp_creds_val, project=temp_project_id_val, location="global")
                     print(f"INFO: Successfully validated a credential from Credential Manager (Project: {temp_project_id_val}). Initialization check passed.")
                     return True
                 except Exception as e_val: