Update app.py

app.py

@@ -1,104 +1,53 @@
 from fastapi import FastAPI, Request
-from pydantic import BaseModel, Extra
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
-import time
-import uuid
-from typing import Optional, List, Any
+from fastapi.responses import JSONResponse
+import json
 
-# --- Configuration ---
-MODEL_ID = "deepseek-ai/deepseek-coder-1.3b-instruct"
-DEVICE = "cpu"
-
-# --- Chargement du modèle et du tokenizer ---
-print(f"Début du chargement du modèle : {MODEL_ID}")
-model = AutoModelForCausalLM.from_pretrained(
-    MODEL_ID,
-    torch_dtype=torch.bfloat16,
-    device_map=DEVICE
-)
-tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
-print("Modèle et tokenizer chargés avec succès sur le CPU.")
-
-# --- Création de l'application API ---
+# --- Création de l'application API de diagnostic ---
 app = FastAPI()
 
-# --- Modèles de données pour la compatibilité OpenAI ---
-class ChatMessage(BaseModel):
-    role: str
-    content: str
-
-class ChatCompletionRequest(BaseModel):
-    # On rend presque tout optionnel pour maximiser la compatibilité
-    model: Optional[str] = None
-    messages: Optional[List[ChatMessage]] = None
-    prompt: Optional[str] = None # Certaines extensions envoient "prompt" au lieu de "messages"
-    max_tokens: Optional[int] = 250
-
-    # LA MODIFICATION LA PLUS IMPORTANTE : Ignorer les champs inconnus
-    class Config:
-        extra = Extra.ignore
-
-class ChatCompletionResponseChoice(BaseModel):
-    index: int = 0
-    message: ChatMessage
-    finish_reason: str = "stop"
-
-class ChatCompletionResponse(BaseModel):
-    id: str
-    object: str = "chat.completion"
-    created: int
-    model: str
-    choices: List[ChatCompletionResponseChoice]
-
-class ModelData(BaseModel):
-    id: str
-    object: str = "model"
-    created: int = int(time.time())
-    owned_by: str = "user"
+# --- Définition des API de diagnostic ---
 
-class ModelList(BaseModel):
-    object: str = "list"
-    data: List[ModelData]
-
-# --- Définition des API ---
-
-@app.get("/models", response_model=ModelList)
+@app.get("/models")
 async def list_models():
-    """Endpoint pour lister les modèles disponibles."""
-    return ModelList(data=[ModelData(id=MODEL_ID)])
-
-@app.post("/chat/completions", response_model=ChatCompletionResponse)
-async def create_chat_completion(request: ChatCompletionRequest):
-    """Endpoint principal pour la génération de texte."""
-    user_prompt = ""
-    # On cherche le prompt de l'utilisateur de plusieurs manières possibles
-    if request.prompt:
-        user_prompt = request.prompt
-    elif request.messages and request.messages[-1].role == "user":
-        user_prompt = request.messages[-1].content
+    """Répond à la requête GET /models pour que l'extension soit satisfaite."""
+    print("--- REQUETE RECUE SUR /models ---")
+    return {"object": "list", "data": [{"id": "deepseek-ai/deepseek-coder-1.3b-instruct", "object": "model"}]}
+
+@app.post("/chat/completions")
+async def debug_chat_completion(request: Request):
+    """
+    Endpoint qui ne fait qu'une seule chose :
+    afficher le contenu exact de la requête envoyée par VS Code.
+    """
+    print("\n\n" + "="*50)
+    print("=== REQUETE POST RECUE SUR /chat/completions ===")
     
-    if not user_prompt:
-        return {"error": "Could not find a valid prompt in the request."}
-
-    messages_for_model = [{'role': 'user', 'content': user_prompt}]
-    inputs = tokenizer.apply_chat_template(messages_for_model, add_generation_prompt=True, return_tensors="pt").to(DEVICE)
+    # On affiche les headers de la requête
+    print("\n--- HEADERS ---")
+    for name, value in request.headers.items():
+        print(f"{name}: {value}")
     
-    outputs = model.generate(inputs, max_new_tokens=request.max_tokens, do_sample=True, temperature=0.2, top_k=50, top_p=0.95, num_return_sequences=1, eos_token_id=tokenizer.eos_token_id)
+    # On essaie de lire et d'afficher le corps (body) de la requête
+    try:
+        body = await request.json()
+        print("\n--- BODY (JSON) ---")
+        # On utilise json.dumps pour un affichage propre
+        print(json.dumps(body, indent=2))
+    except Exception as e:
+        print(f"\n--- ERREUR LORS DE LA LECTURE DU BODY ---")
+        print(f"L'erreur est : {e}")
+        # On essaie de lire le corps comme du texte brut si le JSON échoue
+        body_raw = await request.body()
+        print("\n--- BODY (BRUT) ---")
+        print(body_raw.decode('utf-8', errors='ignore'))
+
+    print("="*50 + "\n\n")
     
-    response_text = tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True)
-
-    response_message = ChatMessage(role="assistant", content=response_text)
-    choice = ChatCompletionResponseChoice(message=response_message)
-    completion_response = ChatCompletionResponse(
-        id=f"chatcmpl-{uuid.uuid4()}",
-        created=int(time.time()),
-        model=MODEL_ID,
-        choices=[choice]
-    )
-
-    return completion_response
+    # On renvoie une erreur 422 volontairement pour pouvoir retenter facilement.
+    # Le but n'est pas que ça marche, mais de voir les logs.
+    error_message = {"error": "Mode diagnostic actif. Vérifiez les logs du Space."}
+    return JSONResponse(status_code=422, content=error_message)
 
 @app.get("/")
 def root():
-    return {"status": "API compatible OpenAI en ligne", "model_id": MODEL_ID}
+    return {"status": "API en mode diagnostic. Vérifiez les logs."}