Update app.py

app.py

@@ -3,7 +3,8 @@ import json
 import logging
 import time
 from gradio_client import Client
-from json.decoder import JSONDecodeError  # Import JSONDecodeError
+from json.decoder import JSONDecodeError
+import httpx  # Import httpx for potential timeout adjustments
 
 app = Flask(__name__)
 
@@ -12,60 +13,15 @@ logging.basicConfig(level=logging.INFO,
                     format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Initialize JARVIS client
-jarvis = None # Initialize as None
-
-def initialize_jarvis_client(max_retries=3, retry_delay=5):
-    global jarvis # Use the global jarvis variable
-    for attempt in range(max_retries):
-        try:
-            jarvis = Client("hadadrjt/ai")
-            logger.info("JARVIS client initialized successfully.")
-            return True # Indicate success
-        except JSONDecodeError as e: # Catch JSONDecodeError specifically
-            logger.warning(f"Attempt {attempt + 1}/{max_retries}: JSONDecodeError during JARVIS client initialization: {e}")
-            if attempt < max_retries - 1:
-                time.sleep(retry_delay)  # Wait before retrying
-            else:
-                logger.error("Max retries reached. JARVIS client initialization failed due to JSONDecodeError.")
-                return False # Indicate failure
-        except Exception as e: # Catch other exceptions as well
-            logger.error(f"Attempt {attempt + 1}/{max_retries}: Error during JARVIS client initialization: {e}")
-            if attempt < max_retries - 1:
-                time.sleep(retry_delay)
-            else:
-                logger.error("Max retries reached. JARVIS client initialization failed due to general exception.")
-                return False # Indicate failure
-    return False # Return False if loop completes without success
-
-
-if not initialize_jarvis_client(): # Initialize client with retry mechanism
-    print("Failed to initialize JARVIS client after multiple retries. API will likely not function correctly.")
-    # It's up to you if you want to exit here or let the Flask app start but potentially fail on requests.
-    # For now, let's continue and handle potential None jarvis later.
-
+# Initialize JARVIS client - LAZY INITIALIZATION - Initialize as None initially
+jarvis = None
+JARVIS_INIT_LOCK = False # Use a simple lock to prevent race conditions in lazy init
 
 # Define available models
 models = [
     "JARVIS: 2.1.2",
     "DeepSeek: V3-0324",
-    "DeepSeek: R1 (Reasoning)",
-    "DeepSeek: R1 - Distill Qwen 14B (Reasoning)",
-    "DeepSeek: R1 - Distill Qwen 32B (Reasoning)",
-    "DeepSeek: R1 - Distill Llama 70B (Reasoning)",
-    "Google: Gemini 2.0 Flash Thinking (Reasoning)",
-    "Google: Gemini 2.5 Pro",
-    "Google: Gemma 3 1B-IT",
-    "Google: Gemma 3 4B-IT",
-    "Google: Gemma 3 27B-IT",
-    "Meta: Llama 3.1 8B Instruct",
-    "Meta: Llama 3.2 3B Instruct",
-    "Meta: Llama 3.3 70B Instruct",
-    "Meta: Llama 4 Maverick 17B 128E Instruct",
-    "Meta: Llama 4 Scout 17B 16E Instruct",
-    "Qwen: Qwen2.5 VL 3B Instruct",
-    "Qwen: Qwen2.5 VL 32B Instruct",
-    "Qwen: Qwen2.5 VL 72B Instruct",
+    # ... (rest of your models list)
     "Agentica: Deepcoder 14B Preview"
 ]
 
@@ -79,12 +35,58 @@ def authenticate_request(request):
     provided_api_key = auth_header.split(' ')[1]
     return provided_api_key == API_KEY
 
+
+def get_jarvis_client():
+    global jarvis, JARVIS_INIT_LOCK
+    if jarvis is None and not JARVIS_INIT_LOCK: # Check if client is None AND not already initializing
+        JARVIS_INIT_LOCK = True # Set the lock
+        max_retries = 5 # Increased retries
+        retry_delay = 5
+        for attempt in range(max_retries):
+            try:
+                logger.info(f"Attempting to initialize JARVIS client (attempt {attempt+1}/{max_retries})...")
+                jarvis = Client("hadadrjt/ai", client_kwargs={"timeout": httpx.Timeout(60.0)}) # Increased timeout, specify in client_kwargs
+                logger.info("JARVIS client initialized successfully.")
+                JARVIS_INIT_LOCK = False # Release the lock on success
+                return jarvis # Return the initialized client
+            except JSONDecodeError as e:
+                logger.warning(f"Attempt {attempt + 1}/{max_retries}: JSONDecodeError during JARVIS client initialization: {e}")
+                try: # Try to get the raw response content for debugging
+                    response = e.doc # Access the problematic JSON string (if available in exception)
+                    logger.warning(f"Problematic response content: {response[:200]}...") # Log first 200 chars
+                except:
+                    logger.warning("Could not retrieve problematic response content.")
+
+                if attempt < max_retries - 1:
+                    time.sleep(retry_delay)
+                else:
+                    logger.error("Max retries reached. JARVIS client initialization failed due to JSONDecodeError.")
+                    JARVIS_INIT_LOCK = False # Release the lock even on failure
+                    return None # Indicate failure
+            except Exception as e:
+                logger.error(f"Attempt {attempt + 1}/{max_retries}: Error during JARVIS client initialization: {e}")
+                if attempt < max_retries - 1:
+                    time.sleep(retry_delay)
+                else:
+                    logger.error("Max retries reached. JARVIS client initialization failed due to general exception.")
+                    JARVIS_INIT_LOCK = False # Release lock even on failure
+                    return None # Indicate failure
+        JARVIS_INIT_LOCK = False # Ensure lock is released if loop exits without success
+
+    elif JARVIS_INIT_LOCK:
+        logger.info("JARVIS client initialization is already in progress, waiting...")
+        while JARVIS_INIT_LOCK: # Wait for initialization to complete (or fail)
+            time.sleep(1) # Wait a bit to avoid busy loop
+
+    return jarvis # Return existing or newly initialized (or None if failed)
+
 @app.route("/v1/chat/completions", methods=["POST"])
 def chat_completions():
     if not authenticate_request(request):
         return jsonify({"error": {"message": "Invalid API key", "code": "invalid_api_key"}}), 401
 
-    if jarvis is None: # Check if jarvis client is initialized
+    current_jarvis = get_jarvis_client() # Get the client (initialize if needed)
+    if current_jarvis is None:
         return jsonify({"error": {"message": "JARVIS client failed to initialize. API not available.", "code": "jarvis_not_initialized"}}), 500
 
 
@@ -93,44 +95,27 @@ def chat_completions():
     model = data.get("model", "JARVIS: 2.1.2")
     stream = data.get("stream", False)
 
-    # Validate messages
+    # Validate messages (same as before)
     if not isinstance(messages, list):
-        return jsonify({"error": {"message": "'messages' must be a list", "code": "invalid_message_list"}}), 400
-
+        return jsonify({"error": ..., "code": ...}), 400
     for message in messages:
         if not isinstance(message, dict) or 'role' not in message or 'content' not in message:
-            return jsonify({"error": {"message": "Each message must have a 'role' and a 'content'", "code": "invalid_message"}}), 400
+            return jsonify({"error": ..., "code": ...}), 400
 
-    # Extract the last message content
     last_message = messages[-1]["content"]
 
     try:
-        # Get full response with context
-        jarvis.predict(new=model, api_name="/change_model")
-        result = jarvis.predict(multi={"text": last_message}, api_name="/api")
+        current_jarvis.predict(new=model, api_name="/change_model")
+        result = current_jarvis.predict(multi={"text": last_message}, api_name="/api")
         response_text = result[0][0][1]
 
-        # Create OpenAI compatible response
-        response = {
-            "id": f"chatcmpl-{int(time.time())}",
-            "object": "chat.completion",
-            "created": int(time.time()),
-            "choices": [{
-                "index": 0,
-                "message": {
-                    "role": "assistant",
-                    "content": response_text
-                },
-                "finish_reason": "stop"
-            }],
-            "usage": {
-                "prompt_tokens": 0,
-                "completion_tokens": 0,
-                "total_tokens": 0
-            }
+        response_data = { # OpenAI compatible response (same as before)
+            "id": ..., "object": ..., "created": ...,
+            "choices": [{ "index": 0, "message": { "role": "assistant", "content": response_text }, "finish_reason": "stop" }],
+            "usage": { "prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0 }
         }
+        return jsonify(response_data)
 
-        return jsonify(response)
     except Exception as e:
         logger.error(f"Error processing request: {str(e)}")
         return jsonify({"error": {"message": str(e), "code": "jarvis_error"}}), 500
@@ -139,11 +124,13 @@ def chat_completions():
 def list_models():
     if not authenticate_request(request):
         return jsonify({"error": {"message": "Invalid API key", "code": "invalid_api_key"}}), 401
-    if jarvis is None: # Check if jarvis client is initialized
-        return jsonify({"error": {"message": "JARVIS client failed to initialize. API not available.", "code": "jarvis_not_initialized"}}), 500
 
+    current_jarvis = get_jarvis_client() # Get the client (initialize if needed)
+    if current_jarvis is None:
+        return jsonify({"error": {"message": "JARVIS client failed to initialize. API not available.", "code": "jarvis_not_initialized"}}), 500
 
     return jsonify({"data": [{"id": model} for model in models], "object": "list"})
 
+
 if __name__ == "__main__":
     app.run(host='0.0.0.0', port=7860)