addeed search for openai

app/openai_handler.py

@@ -140,21 +140,26 @@ class OpenAIDirectHandler:
             api_key=gcp_token,  # OAuth token
         )
     
-    def prepare_openai_params(self, request: OpenAIRequest, model_id: str) -> Dict[str, Any]:
-        """Prepare parameters for OpenAI API call."""
-        params = {
-            "model": model_id,
-            "messages": [msg.model_dump(exclude_unset=True) for msg in request.messages],
-            "temperature": request.temperature,
-            "max_tokens": request.max_tokens,
-            "top_p": request.top_p,
-            "stream": request.stream,
-            "stop": request.stop,
-            "seed": request.seed,
-            "n": request.n,
-        }
-        # Remove None values
-        return {k: v for k, v in params.items() if v is not None}
+    def prepare_openai_params(self, request: OpenAIRequest, model_id: str, is_openai_search: bool = False) -> Dict[str, Any]:
+        """
+        Prepare parameters for OpenAI API call by converting the request to a dictionary,
+        and then overriding the model. This is more robust than manually picking parameters.
+        """
+        # Convert the request to a dict, excluding unset values. `None` values inside
+        # nested models (like messages) are preserved.
+        params = request.model_dump(exclude_unset=True)
+        
+        # Update model and filter out top-level None values.
+        params['model'] = model_id
+        
+        if is_openai_search:
+            params['web_search_options'] = {}
+            
+        openai_params = {k: v for k, v in params.items() if v is not None}
+        if "reasoning_effort" in openai_params and openai_params["reasoning_effort"] not in ["low", "medium", "high"]:
+            del openai_params["reasoning_effort"]
+        return openai_params
+    
     
     def prepare_extra_body(self) -> Dict[str, Any]:
         """Prepare extra body parameters for OpenAI API call."""
@@ -171,7 +176,7 @@ class OpenAIDirectHandler:
         }
     
     async def handle_streaming_response(
-        self, 
+        self,
         openai_client: Any, # Can be openai.AsyncOpenAI or our wrapper
         openai_params: Dict[str, Any],
         openai_extra_body: Dict[str, Any],
@@ -398,7 +403,7 @@ class OpenAIDirectHandler:
                 content=create_openai_error_response(500, error_msg, "server_error")
             )
     
-    async def process_request(self, request: OpenAIRequest, base_model_name: str, is_express: bool = False):
+    async def process_request(self, request: OpenAIRequest, base_model_name: str, is_express: bool = False, is_openai_search: bool = False):
         """Main entry point for processing OpenAI Direct mode requests."""
         print(f"INFO: Using OpenAI Direct Path for model: {request.model} (Express: {is_express})")
         
@@ -434,7 +439,7 @@ class OpenAIDirectHandler:
                 client = self.create_openai_client(rotated_project_id, gcp_token)
 
             model_id = f"google/{base_model_name}"
-            openai_params = self.prepare_openai_params(request, model_id)
+            openai_params = self.prepare_openai_params(request, model_id, is_openai_search)
             openai_extra_body = self.prepare_extra_body()
             
             if request.stream:

app/routes/chat_api.py

@@ -33,6 +33,7 @@ async def chat_completions(fastapi_request: Request, request: OpenAIRequest, api
     try:
         credential_manager_instance = fastapi_request.app.state.credential_manager
         OPENAI_DIRECT_SUFFIX = "-openai"
+        OPENAI_SEARCH_SUFFIX = "-openaisearch"
         EXPERIMENTAL_MARKER = "-exp-"
         PAY_PREFIX = "[PAY]"
         EXPRESS_PREFIX = "[EXPRESS] " # Note the space for easier stripping
@@ -44,8 +45,11 @@ async def chat_completions(fastapi_request: Request, request: OpenAIRequest, api
 
         # Updated logic for is_openai_direct_model
         is_openai_direct_model = False
-        if request.model.endswith(OPENAI_DIRECT_SUFFIX):
-            temp_name_for_marker_check = request.model[:-len(OPENAI_DIRECT_SUFFIX)]
+        is_openai_search_model = False
+        if request.model.endswith(OPENAI_DIRECT_SUFFIX) or request.model.endswith(OPENAI_SEARCH_SUFFIX):
+            is_openai_search_model = request.model.endswith(OPENAI_SEARCH_SUFFIX)
+            suffix_to_remove = OPENAI_SEARCH_SUFFIX if is_openai_search_model else OPENAI_DIRECT_SUFFIX
+            temp_name_for_marker_check = request.model[:-len(suffix_to_remove)]
             # An OpenAI model can be prefixed with PAY, EXPRESS, or contain EXP
             if temp_name_for_marker_check.startswith(PAY_PREFIX) or \
                temp_name_for_marker_check.startswith(EXPRESS_PREFIX) or \
@@ -75,7 +79,8 @@ async def chat_completions(fastapi_request: Request, request: OpenAIRequest, api
         if is_openai_direct_model: # This check is based on request.model, so it's fine here
             # If it was an OpenAI direct model, its base name is request.model minus suffix.
             # We need to ensure PAY_PREFIX or EXPRESS_PREFIX are also stripped if they were part of the original.
-            temp_base_for_openai = request.model[:-len(OPENAI_DIRECT_SUFFIX)]
+            suffix_to_remove = OPENAI_SEARCH_SUFFIX if is_openai_search_model else OPENAI_DIRECT_SUFFIX
+            temp_base_for_openai = request.model[:-len(suffix_to_remove)]
             if temp_base_for_openai.startswith(EXPRESS_PREFIX):
                 temp_base_for_openai = temp_base_for_openai[len(EXPRESS_PREFIX):]
             if temp_base_for_openai.startswith(PAY_PREFIX):
@@ -187,10 +192,10 @@ async def chat_completions(fastapi_request: Request, request: OpenAIRequest, api
             # Use the new OpenAI handler
             if is_express_model_request:
                 openai_handler = OpenAIDirectHandler(express_key_manager=express_key_manager_instance)
-                return await openai_handler.process_request(request, base_model_name, is_express=True)
+                return await openai_handler.process_request(request, base_model_name, is_express=True, is_openai_search=is_openai_search_model)
             else:
                 openai_handler = OpenAIDirectHandler(credential_manager=credential_manager_instance)
-                return await openai_handler.process_request(request, base_model_name)
+                return await openai_handler.process_request(request, base_model_name, is_openai_search=is_openai_search_model)
         elif is_auto_model:
             print(f"Processing auto model: {request.model}")
             attempts = [

app/routes/models_api.py

@@ -15,6 +15,7 @@ async def list_models(fastapi_request: Request, api_key: str = Depends(get_api_k
     PAY_PREFIX = "[PAY]"
     EXPRESS_PREFIX = "[EXPRESS] "
     OPENAI_DIRECT_SUFFIX = "-openai"
+    OPENAI_SEARCH_SUFFIX = "-openaisearch"
     
     credential_manager_instance: CredentialManager = fastapi_request.app.state.credential_manager
     express_key_manager_instance = fastapi_request.app.state.express_key_manager
@@ -41,6 +42,7 @@ async def list_models(fastapi_request: Request, api_key: str = Depends(get_api_k
         
         # Add the openai variant for all models
         suffixes.append(OPENAI_DIRECT_SUFFIX)
+        suffixes.append(OPENAI_SEARCH_SUFFIX)
 
         for suffix in suffixes:
             model_id_with_suffix = f"{base_id}{suffix}"