Update app.py

app.py

@@ -56,21 +56,19 @@ app = FastAPI()
 
 # --- Tool Execution Functions ---
 def execute_browse_tool(url: str) -> str:
-    """Visits a URL, extracts text content, and returns it."""
     try:
         headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'}
         response = requests.get(url, headers=headers, timeout=10)
         response.raise_for_status()
         soup = BeautifulSoup(response.content, 'html.parser')
-        # Remove script and style elements
         for script in soup(["script", "style"]):
             script.decompose()
         text = soup.get_text(separator='\n', strip=True)
-        return f"Content from {url}:\n\n{text[:4000]}" # Limit context size
+        return f"Content from {url}:\n\n{text[:4000]}"
     except Exception as e:
         return f"Error browsing {url}: {str(e)}"
 
-# --- Pydantic Models --- (Same as before)
+# --- Pydantic Models ---
 class ContentPart(BaseModel): type: str; text: str
 class ChatMessage(BaseModel): role: str; content: Union[str, List[ContentPart]]
 class ChatCompletionRequest(BaseModel):
@@ -97,30 +95,27 @@ async def create_chat_completion(request: ChatCompletionRequest):
 
     if not user_prompt: return {"error": "Prompt not found."}
 
-    # --- AGENT LOGIC ---
-    # STEP 1: Ask the model to think and decide on a tool
     initial_messages = [{'role': 'system', 'content': SYSTEM_PROMPT}, {'role': 'user', 'content': user_prompt}]
     inputs = tokenizer.apply_chat_template(initial_messages, add_generation_prompt=True, return_tensors="pt").to(DEVICE)
-    outputs = model.generate(inputs.input_ids, attention_mask=inputs.attention_mask, max_new_tokens=150, eos_token_id=tokenizer.eos_token_id)
-    thought_process = tokenizer.decode(outputs[0][len(inputs.input_ids[0]):], skip_special_tokens=True)
+    
+    # CORRECTION ICI : On utilise **inputs pour décompresser le dictionnaire
+    outputs = model.generate(**inputs, max_new_tokens=150, eos_token_id=tokenizer.eos_token_id)
+    thought_process = tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
 
     tool_call = None
     try:
-        # Check if the model's output is a JSON for a tool call
         json_part = thought_process[thought_process.find('{'):thought_process.rfind('}')+1]
         if json_part:
             tool_call = json.loads(json_part)
     except json.JSONDecodeError:
         tool_call = None
 
-    # STEP 2: Execute the tool if requested
     if tool_call and 'tool' in tool_call:
         tool_context = ""
         if tool_call['tool'] == 'browse' and 'url' in tool_call:
             print(f"--- AGENT: Browsing URL: {tool_call['url']} ---")
             tool_context = execute_browse_tool(tool_call['url'])
         
-        # STEP 3: Call the model AGAIN with the new context
         final_messages = [
             {'role': 'system', 'content': SYSTEM_PROMPT},
             {'role': 'user', 'content': user_prompt},
@@ -128,21 +123,20 @@ async def create_chat_completion(request: ChatCompletionRequest):
             {'role': 'system', 'content': "Now, provide the final, complete answer to the user based on this information."}
         ]
     else:
-        # If no tool is needed, just use the original thought process
         final_messages = [
             {'role': 'system', 'content': SYSTEM_PROMPT},
             {'role': 'user', 'content': user_prompt},
-            {'role': 'assistant', 'content': thought_process} # The model decided to answer directly
+            {'role': 'assistant', 'content': thought_process}
         ]
 
-    # --- FINAL RESPONSE GENERATION (Streaming) ---
     final_inputs = tokenizer.apply_chat_template(final_messages, add_generation_prompt=False, return_tensors="pt").to(DEVICE)
-    final_outputs = model.generate(final_inputs.input_ids, attention_mask=final_inputs.attention_mask, max_new_tokens=1024, do_sample=True, temperature=0.1, top_k=50, top_p=0.95, eos_token_id=tokenizer.eos_token_id)
-    response_text = tokenizer.decode(final_outputs[0][len(final_inputs.input_ids[0]):], skip_special_tokens=True)
+    
+    # DEUXIÈME CORRECTION ICI : On utilise également **final_inputs
+    final_outputs = model.generate(**final_inputs, max_new_tokens=1024, do_sample=True, temperature=0.1, top_k=50, top_p=0.95, eos_token_id=tokenizer.eos_token_id)
+    response_text = tokenizer.decode(final_outputs[0][len(final_inputs['input_ids'][0]):], skip_special_tokens=True)
 
     async def stream_generator():
         response_id = f"chatcmpl-{uuid.uuid4()}"
-        # (Streaming logic is the same as before)
         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}]}
             yield f"data: {json.dumps(chunk)}\n\n"