added thinking support. added nothinking and maxthinking mode

src/config.py

@@ -131,17 +131,110 @@ def _generate_search_variants():
             search_models.append(search_variant)
     return search_models
 
-# Supported Models (includes both base models and search variants)
-SUPPORTED_MODELS = BASE_MODELS + _generate_search_variants()
+# Generate thinking variants for applicable models
+def _generate_thinking_variants():
+    """Generate nothinking and maxthinking variants for models that support thinking."""
+    thinking_models = []
+    for model in BASE_MODELS:
+        # Only add thinking variants for models that support content generation
+        # and contain "gemini-2.5-flash" or "gemini-2.5-pro" in their name
+        if ("generateContent" in model["supportedGenerationMethods"] and
+            ("gemini-2.5-flash" in model["name"] or "gemini-2.5-pro" in model["name"])):
+            
+            # Add -nothinking variant
+            nothinking_variant = model.copy()
+            nothinking_variant["name"] = model["name"] + "-nothinking"
+            nothinking_variant["displayName"] = model["displayName"] + " (No Thinking)"
+            nothinking_variant["description"] = model["description"] + " (thinking disabled)"
+            thinking_models.append(nothinking_variant)
+            
+            # Add -maxthinking variant
+            maxthinking_variant = model.copy()
+            maxthinking_variant["name"] = model["name"] + "-maxthinking"
+            maxthinking_variant["displayName"] = model["displayName"] + " (Max Thinking)"
+            maxthinking_variant["description"] = model["description"] + " (maximum thinking budget)"
+            thinking_models.append(maxthinking_variant)
+    return thinking_models
+
+# Generate combined variants (search + thinking combinations)
+def _generate_combined_variants():
+    """Generate combined search and thinking variants."""
+    combined_models = []
+    for model in BASE_MODELS:
+        # Only add combined variants for models that support content generation
+        # and contain "gemini-2.5-flash" or "gemini-2.5-pro" in their name
+        if ("generateContent" in model["supportedGenerationMethods"] and
+            ("gemini-2.5-flash" in model["name"] or "gemini-2.5-pro" in model["name"])):
+            
+            # search + nothinking
+            search_nothinking = model.copy()
+            search_nothinking["name"] = model["name"] + "-search-nothinking"
+            search_nothinking["displayName"] = model["displayName"] + " with Google Search (No Thinking)"
+            search_nothinking["description"] = model["description"] + " (includes Google Search grounding, thinking disabled)"
+            combined_models.append(search_nothinking)
+            
+            # search + maxthinking
+            search_maxthinking = model.copy()
+            search_maxthinking["name"] = model["name"] + "-search-maxthinking"
+            search_maxthinking["displayName"] = model["displayName"] + " with Google Search (Max Thinking)"
+            search_maxthinking["description"] = model["description"] + " (includes Google Search grounding, maximum thinking budget)"
+            combined_models.append(search_maxthinking)
+    return combined_models
+
+# Supported Models (includes base models, search variants, and thinking variants)
+SUPPORTED_MODELS = BASE_MODELS + _generate_search_variants() + _generate_thinking_variants()
 
-# Helper function to get base model name from search variant
+# Helper function to get base model name from any variant
 def get_base_model_name(model_name):
-    """Convert search variant model name to base model name."""
-    if model_name.endswith("-search"):
-        return model_name[:-7]  # Remove "-search" suffix
+    """Convert variant model name to base model name."""
+    # Remove all possible suffixes in order
+    suffixes = ["-maxthinking", "-nothinking", "-search"]
+    for suffix in suffixes:
+        if model_name.endswith(suffix):
+            return model_name[:-len(suffix)]
     return model_name
 
 # Helper function to check if model uses search grounding
 def is_search_model(model_name):
     """Check if model name indicates search grounding should be enabled."""
-    return model_name.endswith("-search")
+    return "-search" in model_name
+
+# Helper function to check if model uses no thinking
+def is_nothinking_model(model_name):
+    """Check if model name indicates thinking should be disabled."""
+    return "-nothinking" in model_name
+
+# Helper function to check if model uses max thinking
+def is_maxthinking_model(model_name):
+    """Check if model name indicates maximum thinking budget should be used."""
+    return "-maxthinking" in model_name
+
+# Helper function to get thinking budget for a model
+def get_thinking_budget(model_name):
+    """Get the appropriate thinking budget for a model based on its name and variant."""
+    base_model = get_base_model_name(model_name)
+    
+    if is_nothinking_model(model_name):
+        if "gemini-2.5-flash" in base_model:
+            return 0  # No thinking for flash
+        elif "gemini-2.5-pro" in base_model:
+            return 128  # Limited thinking for pro
+    elif is_maxthinking_model(model_name):
+        if "gemini-2.5-flash" in base_model:
+            return 24576
+        elif "gemini-2.5-pro" in base_model:
+            return 32768
+    else:
+        # Default thinking budget for regular models
+        return -1  # Default for all models
+
+# Helper function to check if thinking should be included in output
+def should_include_thoughts(model_name):
+    """Check if thoughts should be included in the response."""
+    if is_nothinking_model(model_name):
+        # For nothinking mode, still include thoughts if it's a pro model
+        base_model = get_base_model_name(model_name)
+        return "gemini-2.5-pro" in base_model
+    else:
+        # For all other modes, include thoughts
+        return True

src/google_api_client.py

@@ -11,7 +11,14 @@ from google.auth.transport.requests import Request as GoogleAuthRequest
 
 from .auth import get_credentials, save_credentials, get_user_project_id, onboard_user
 from .utils import get_user_agent
-from .config import CODE_ASSIST_ENDPOINT, DEFAULT_SAFETY_SETTINGS, get_base_model_name, is_search_model
+from .config import (
+    CODE_ASSIST_ENDPOINT,
+    DEFAULT_SAFETY_SETTINGS,
+    get_base_model_name,
+    is_search_model,
+    get_thinking_budget,
+    should_include_thoughts
+)
 import asyncio
 
 
@@ -307,8 +314,12 @@ def build_gemini_payload_from_native(native_request: dict, model_from_path: str)
     if "thinkingConfig" not in native_request["generationConfig"]:
         native_request["generationConfig"]["thinkingConfig"] = {}
     
-    native_request["generationConfig"]["thinkingConfig"]["includeThoughts"] = True
-    native_request["generationConfig"]["thinkingConfig"]["thinkingBudget"] = -1
+    # Configure thinking based on model variant
+    thinking_budget = get_thinking_budget(model_from_path)
+    include_thoughts = should_include_thoughts(model_from_path)
+    
+    native_request["generationConfig"]["thinkingConfig"]["includeThoughts"] = include_thoughts
+    native_request["generationConfig"]["thinkingConfig"]["thinkingBudget"] = thinking_budget
     
     # Add Google Search grounding for search models
     if is_search_model(model_from_path):

src/models.py

@@ -5,6 +5,7 @@ from typing import List, Optional, Union, Dict, Any
 class OpenAIChatMessage(BaseModel):
     role: str
     content: Union[str, List[Dict[str, Any]]]
+    reasoning_content: Optional[str] = None
 
 class OpenAIChatCompletionRequest(BaseModel):
     model: str
@@ -37,6 +38,7 @@ class OpenAIChatCompletionResponse(BaseModel):
 
 class OpenAIDelta(BaseModel):
     content: Optional[str] = None
+    reasoning_content: Optional[str] = None
 
 class OpenAIChatCompletionStreamChoice(BaseModel):
     index: int

src/openai_transformers.py

@@ -8,7 +8,13 @@ import uuid
 from typing import Dict, Any
 
 from .models import OpenAIChatCompletionRequest, OpenAIChatCompletionResponse
-from .config import DEFAULT_SAFETY_SETTINGS, is_search_model, get_base_model_name
+from .config import (
+    DEFAULT_SAFETY_SETTINGS,
+    is_search_model,
+    get_base_model_name,
+    get_thinking_budget,
+    should_include_thoughts
+)
 
 
 def openai_request_to_gemini(openai_request: OpenAIChatCompletionRequest) -> Dict[str, Any]:
@@ -103,6 +109,14 @@ def openai_request_to_gemini(openai_request: OpenAIChatCompletionRequest) -> Dic
     if is_search_model(openai_request.model):
         request_payload["tools"] = [{"googleSearch": {}}]
     
+    # Add thinking configuration for thinking models
+    thinking_budget = get_thinking_budget(openai_request.model)
+    if thinking_budget is not None:
+        request_payload["generationConfig"]["thinkingConfig"] = {
+            "thinkingBudget": thinking_budget,
+            "includeThoughts": should_include_thoughts(openai_request.model)
+        }
+    
     return request_payload
 
 
@@ -126,18 +140,34 @@ def gemini_response_to_openai(gemini_response: Dict[str, Any], model: str) -> Di
         if role == "model":
             role = "assistant"
         
-        # Extract text content from parts
+        # Extract and separate thinking tokens from regular content
         parts = candidate.get("content", {}).get("parts", [])
         content = ""
-        if parts and len(parts) > 0:
-            content = parts[0].get("text", "")
+        reasoning_content = ""
+        
+        for part in parts:
+            if not part.get("text"):
+                continue
+            
+            # Check if this part contains thinking tokens
+            if part.get("thought", False):
+                reasoning_content += part.get("text", "")
+            else:
+                content += part.get("text", "")
+        
+        # Build message object
+        message = {
+            "role": role,
+            "content": content,
+        }
+        
+        # Add reasoning_content if there are thinking tokens
+        if reasoning_content:
+            message["reasoning_content"] = reasoning_content
         
         choices.append({
             "index": candidate.get("index", 0),
-            "message": {
-                "role": role,
-                "content": content,
-            },
+            "message": message,
             "finish_reason": _map_finish_reason(candidate.get("finishReason")),
         })
     
@@ -171,17 +201,31 @@ def gemini_stream_chunk_to_openai(gemini_chunk: Dict[str, Any], model: str, resp
         if role == "model":
             role = "assistant"
         
-        # Extract text content from parts
+        # Extract and separate thinking tokens from regular content
         parts = candidate.get("content", {}).get("parts", [])
         content = ""
-        if parts and len(parts) > 0:
-            content = parts[0].get("text", "")
+        reasoning_content = ""
+        
+        for part in parts:
+            if not part.get("text"):
+                continue
+            
+            # Check if this part contains thinking tokens
+            if part.get("thought", False):
+                reasoning_content += part.get("text", "")
+            else:
+                content += part.get("text", "")
+        
+        # Build delta object
+        delta = {}
+        if content:
+            delta["content"] = content
+        if reasoning_content:
+            delta["reasoning_content"] = reasoning_content
         
         choices.append({
             "index": candidate.get("index", 0),
-            "delta": {
-                "content": content,
-            },
+            "delta": delta,
             "finish_reason": _map_finish_reason(candidate.get("finishReason")),
         })