Update app.py

app.py

@@ -7,6 +7,7 @@ import time
 import uuid
 import json
 from typing import Optional, List, Union, Dict, Any
+import asyncio
 
 # --- Configuration ---
 MODEL_ID = "deepseek-ai/deepseek-coder-1.3b-instruct"
@@ -20,12 +21,16 @@ model = AutoModelForCausalLM.from_pretrained(
     device_map=DEVICE
 )
 tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+    print("Le pad_token a été défini sur eos_token.")
+
 print("Modèle et tokenizer chargés avec succès sur le CPU.")
 
 # --- Création de l'application API ---
 app = FastAPI()
 
-# --- Modèles de données pour accepter la structure complexe de l'extension ---
+# --- Modèles de données ---
 class ContentPart(BaseModel):
     type: str
     text: str
@@ -38,10 +43,30 @@ class ChatCompletionRequest(BaseModel):
     model: Optional[str] = None
     messages: List[ChatMessage]
     stream: Optional[bool] = False
+    max_tokens: Optional[int] = 512 # Augmenté pour des réponses plus longues
+    
+    # --- LES NOUVEAUX CHAMPS SONT ICI ---
+    # Ajout des paramètres de génération avec des valeurs par défaut.
+    temperature: Optional[float] = 0.4
+    top_p: Optional[float] = 0.95
+    top_k: Optional[int] = 50
     
     class Config:
         extra = Extra.ignore
 
+# ... (le reste des modèles de données est inchangé) ...
+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"
@@ -50,19 +75,15 @@ class ModelData(BaseModel):
 class ModelList(BaseModel):
     object: str = "list"
     data: List[ModelData]
-
+    
 # --- Définition des API ---
 
 @app.get("/models", response_model=ModelList)
 async def list_models():
-    """Répond à la requête GET /models pour satisfaire l'extension."""
     return ModelList(data=[ModelData(id=MODEL_ID)])
 
 @app.post("/chat/completions")
 async def create_chat_completion(request: ChatCompletionRequest):
-    """Endpoint principal qui gère la génération de texte en streaming."""
-    
-    # On extrait le prompt de l'utilisateur de la structure complexe
     user_prompt = ""
     last_message = request.messages[-1]
     if isinstance(last_message.content, list):
@@ -75,61 +96,41 @@ async def create_chat_completion(request: ChatCompletionRequest):
     if not user_prompt:
         return {"error": "Prompt non trouvé."}
 
-    # Préparation pour le modèle DeepSeek
     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)
+    text_prompt = tokenizer.apply_chat_template(messages_for_model, tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer(text_prompt, return_tensors="pt", padding=True).to(DEVICE)
+    
+    # --- LA MISE À JOUR EST ICI ---
+    # On utilise maintenant les paramètres de la requête pour la génération.
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=request.max_tokens,
+        do_sample=True, # do_sample doit être True pour que temp, top_p et top_k aient un effet
+        temperature=request.temperature,
+        top_p=request.top_p,
+        top_k=request.top_k,
+        eos_token_id=tokenizer.eos_token_id
+    )
     
-    # Génération de la réponse complète
-    outputs = model.generate(inputs, max_new_tokens=250, do_sample=True, temperature=0.2, top_k=50, top_p=0.95, num_return_sequences=1, eos_token_id=tokenizer.eos_token_id)
-    response_text = tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True)
+    response_text = tokenizer.decode(outputs[0, inputs['input_ids'].shape[1]:], skip_special_tokens=True)
 
-    # Fonction génératrice pour le streaming
     async def stream_generator():
         response_id = f"chatcmpl-{uuid.uuid4()}"
         
-        # On envoie la réponse caractère par caractère, au format attendu
         for char in response_text:
-            chunk = {
-                "id": response_id,
-                "object": "chat.completion.chunk",
-                "created": int(time.time()),
-                "model": MODEL_ID,
-                "choices": [{
-                    "index": 0,
-                    "delta": {"content": char},
-                    "finish_reason": None
-                }]
-            }
+            chunk = { "id": response_id, "object": "chat.completion.chunk", "created": int(time.time()), "model": MODEL_ID, "choices": [{"index": 0, "delta": {"content": char}, "finish_reason": None }] }
             yield f"data: {json.dumps(chunk)}\n\n"
-            await asyncio.sleep(0.01) # Petite pause pour simuler un flux
+            await asyncio.sleep(0.01)
         
-        # On envoie le chunk final de fin
-        final_chunk = {
-            "id": response_id,
-            "object": "chat.completion.chunk",
-            "created": int(time.time()),
-            "model": MODEL_ID,
-            "choices": [{
-                "index": 0,
-                "delta": {},
-                "finish_reason": "stop"
-            }]
-        }
+        final_chunk = { "id": response_id, "object": "chat.completion.chunk", "created": int(time.time()), "model": MODEL_ID, "choices": [{"index": 0, "delta": {}, "finish_reason": "stop" }] }
         yield f"data: {json.dumps(final_chunk)}\n\n"
-        
-        # On envoie le signal [DONE]
         yield "data: [DONE]\n\n"
 
-    # Si l'extension demande un stream, on renvoie le générateur
     if request.stream:
         return StreamingResponse(stream_generator(), media_type="text/event-stream")
     else:
-        # Code de secours si le stream n'est pas demandé (peu probable)
         return {"choices": [{"message": {"role": "assistant", "content": response_text}}]}
 
 @app.get("/")
 def root():
-    return {"status": "API compatible OpenAI en ligne (avec streaming)", "model_id": MODEL_ID}
-
-# On a besoin de asyncio pour la pause dans le stream
-import asyncio
+    return {"status": "API compatible OpenAI en ligne (avec streaming et paramètres dynamiques)", "model_id": MODEL_ID}