Update app.py

app.py

@@ -6,44 +6,35 @@ from transformers import AutoModelForCausalLM, AutoTokenizer
 import time, uuid, json, asyncio, requests
 from bs4 import BeautifulSoup
 from typing import Optional, List, Union
+import re # On importe le module pour les expressions régulières
 
 # --- AGENT BRAIN (SYSTEM PROMPT) ---
 SYSTEM_PROMPT = """
-You are a senior expert WordPress and WooCommerce developer, now enhanced with agent-like capabilities. Your primary goal is to provide accurate, well-researched, and secure code solutions.
+You are a highly advanced AI agent specializing in WordPress & WooCommerce development. You must follow a strict "Think, Act, Answer" workflow for every user request. Your primary directive is to be transparent, showing your thought process before taking any action.
 
 ### AGENT WORKFLOW ###
-1.  **Think:** First, analyze the user's request and think step-by-step.
-2.  **Decide:** Decide if you have enough information to answer directly or if you need to use a tool.
-3.  **Act:** If you need a tool, respond ONLY with a single JSON object specifying the tool and its parameters. Do not add any other text.
-4.  **Answer:** If you don't need a tool, or after you have received information from a tool, provide a complete answer to the user.
-
-### AVAILABLE TOOLS ###
-You can request to use one of the following tools by outputting a JSON object:
-
-**1. Web Browser / Page Reader**
--   **Description:** Use this tool to access a specific URL and read its content. This is useful for checking documentation, reading articles, or understanding the context of a webpage.
--   **JSON Format:**
-    ```json
-    {
-      "tool": "browse",
-      "url": "https://www.the-url-to-visit.com"
-    }
-    ```
-
-### CODING RULES (Apply when providing the final answer) ###
-1.  **Never Modify Core Files.**
-2.  **Respect Hooks (actions and filters).**
-3.  **Security First (Escape, Sanitize, Use Nonces).**
-4.  **Prioritize Performance.**
-5.  **Follow WordPress Coding Standards.**
-
-### RESPONSE FORMAT (For the final answer) ###
-1.  A brief explanation of the solution.
-2.  The complete and functional PHP code block.
-3.  A clear instruction on where to place the code.
+You MUST structure your response within the following XML tags. This is not optional.
+
+1.  **<thinking>**
+    -   First, think step-by-step. Analyze the user's request.
+    -   Break down the problem. Formulate a plan.
+    -   Decide if you need to use a tool to gather more information (like checking official documentation for the latest best practices).
+    -   Your entire thought process goes here.
+    </thinking>
+
+2.  **<tool_code>**
+    -   If you decide to use a tool, place the single JSON object for that tool here.
+    -   If you do not need a tool, this tag MUST be empty.
+    -   Example: `{"tool": "browse", "url": "https://developer.wordpress.org/reference/functions/add_action/"}`
+    </tool_code>
+
+3.  **<final_answer>**
+    -   If you can answer the user's request WITHOUT using a tool, formulate the complete and final answer here.
+    -   If you used a tool, leave this tag empty in your first response. You will be given the tool's output and asked to generate the final answer in a second step.
+    </final_answer>
 """
 
-# --- Configuration & Model Loading ---
+# --- Configuration & Model Loading --- (Identique)
 MODEL_ID = "deepseek-ai/deepseek-coder-1.3b-instruct"
 DEVICE = "cpu"
 print(f"Loading model: {MODEL_ID}")
@@ -54,21 +45,20 @@ print("Model and tokenizer loaded successfully.")
 
 app = FastAPI()
 
-# --- Tool Execution Functions ---
+# --- Tool Execution Functions --- (Identique)
 def execute_browse_tool(url: str) -> str:
     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')
-        for script in soup(["script", "style"]):
-            script.decompose()
+        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]}"
     except Exception as e:
         return f"Error browsing {url}: {str(e)}"
 
-# --- Pydantic Models ---
+# --- Pydantic Models --- (Identique)
 class ContentPart(BaseModel): type: str; text: str
 class ChatMessage(BaseModel): role: str; content: Union[str, List[ContentPart]]
 class ChatCompletionRequest(BaseModel):
@@ -79,6 +69,11 @@ class ChatCompletionRequest(BaseModel):
 class ModelData(BaseModel): id: str; object: str = "model"; owned_by: str = "user"
 class ModelList(BaseModel): object: str = "list"; data: List[ModelData]
 
+# --- Helper function to parse XML-like tags ---
+def parse_tag(tag: str, text: str) -> str:
+    match = re.search(f'<{tag}>(.*?)</{tag}>', text, re.DOTALL)
+    return match.group(1).strip() if match else ""
+
 # --- API Endpoints ---
 @app.get("/models", response_model=ModelList)
 async def list_models():
@@ -95,63 +90,73 @@ async def create_chat_completion(request: ChatCompletionRequest):
 
     if not user_prompt: return {"error": "Prompt not found."}
 
-    initial_messages = [{'role': 'system', 'content': SYSTEM_PROMPT}, {'role': 'user', 'content': user_prompt}]
-    
-    # --- CORRECTION ICI : On garantit que 'inputs' est un dictionnaire ---
-    # Étape 1: Formatter le texte
-    formatted_prompt = tokenizer.apply_chat_template(initial_messages, tokenize=False, add_generation_prompt=True)
-    # Étape 2: Tokenizer le texte formaté pour obtenir un dictionnaire
-    inputs = tokenizer(formatted_prompt, return_tensors="pt", padding=True).to(DEVICE)
-    
-    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:
-        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
+    async def stream_agent_process():
+        response_id = f"chatcmpl-{uuid.uuid4()}"
+
+        def stream_chunk(content: str):
+            chunk = {"id": response_id, "object": "chat.completion.chunk", "created": int(time.time()), "model": MODEL_ID, "choices": [{"index": 0, "delta": {"content": content}, "finish_reason": None}]}
+            return f"data: {json.dumps(chunk)}\n\n"
+
+        # --- STEP 1: Planification ---
+        initial_messages = [{'role': 'system', 'content': SYSTEM_PROMPT}, {'role': 'user', 'content': user_prompt}]
+        formatted_prompt = tokenizer.apply_chat_template(initial_messages, tokenize=False, add_generation_prompt=True)
+        inputs = tokenizer(formatted_prompt, return_tensors="pt", padding=True).to(DEVICE)
+        outputs = model.generate(**inputs, max_new_tokens=1024, eos_token_id=tokenizer.eos_token_id)
+        agent_plan = tokenizer.decode(outputs[0][len(inputs['input_ids'][0]):], skip_special_tokens=True)
 
-    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'])
+        thinking_text = parse_tag("thinking", agent_plan)
+        tool_code_text = parse_tag("tool_code", agent_plan)
+        final_answer_text = parse_tag("final_answer", agent_plan)
+
+        # --- STEP 2: Diffusion de la pensée ---
+        if thinking_text:
+            yield stream_chunk(f"🤔 **Thinking...**\n```thought\n{thinking_text}\n```\n\n")
+            await asyncio.sleep(0.1)
+
+        # --- STEP 3: Action & Synthèse ---
+        tool_call = None
+        if tool_code_text:
+            try:
+                tool_call = json.loads(tool_code_text)
+            except json.JSONDecodeError:
+                pass
         
-        final_messages = [
-            {'role': 'system', 'content': SYSTEM_PROMPT},
-            {'role': 'user', 'content': user_prompt},
-            {'role': 'assistant', 'content': f"I have used the browse tool and retrieved the following information:\n{tool_context}"},
-            {'role': 'system', 'content': "Now, provide the final, complete answer to the user based on this information."}
-        ]
-    else:
-        final_messages = [
-            {'role': 'system', 'content': SYSTEM_PROMPT},
-            {'role': 'user', 'content': user_prompt},
-            {'role': 'assistant', 'content': thought_process}
-        ]
-
-    # --- DEUXIÈME CORRECTION ICI : On applique la même logique ---
-    final_formatted_prompt = tokenizer.apply_chat_template(final_messages, tokenize=False, add_generation_prompt=True)
-    final_inputs = tokenizer(final_formatted_prompt, return_tensors="pt", padding=True).to(DEVICE)
-    
-    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()}"
-        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"
-            await asyncio.sleep(0.005)
+        if tool_call and 'tool' in tool_call:
+            # --- Exécution et Diffusion de l'Action ---
+            if tool_call['tool'] == 'browse' and 'url' in tool_call:
+                url = tool_call['url']
+                yield stream_chunk(f"🔎 **Action:** Browsing `{url}`...\n\n")
+                await asyncio.sleep(0.1)
+                tool_context = execute_browse_tool(url)
+            else:
+                tool_context = "Unknown tool requested."
+            
+            # --- Appel de synthèse ---
+            synthesis_messages = [
+                {'role': 'system', 'content': SYSTEM_PROMPT},
+                {'role': 'user', 'content': user_prompt},
+                {'role': 'assistant', 'content': f"<thinking>{thinking_text}</thinking><tool_code>{tool_code_text}</tool_code>"},
+                {'role': 'system', 'content': f"Here is the result from your tool use:\n\n<tool_result>\n{tool_context}\n</tool_result>\n\nNow, generate the final, complete answer inside the <final_answer> tag."}
+            ]
+            synthesis_prompt = tokenizer.apply_chat_template(synthesis_messages, tokenize=False, add_generation_prompt=True)
+            synthesis_inputs = tokenizer(synthesis_prompt, return_tensors="pt", padding=True).to(DEVICE)
+            synthesis_outputs = model.generate(**synthesis_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)
+            final_response = tokenizer.decode(synthesis_outputs[0][len(synthesis_inputs['input_ids'][0]):], skip_special_tokens=True)
+            final_answer_text = parse_tag("final_answer", final_response)
+
+        # --- STEP 4: Diffusion de la Réponse Finale ---
+        if final_answer_text:
+            yield stream_chunk(f"✅ **Final Answer:**\n{final_answer_text}")
+        else:
+            yield stream_chunk("Agent could not generate a final answer.")
+        
+        # --- Fin du stream ---
         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"
         yield "data: [DONE]\n\n"
 
-    return StreamingResponse(stream_generator(), media_type="text/event-stream")
+    return StreamingResponse(stream_agent_process(), media_type="text/event-stream")
 
 @app.get("/")
 def root():
-    return {"status": "Advanced Agent for WordPress/WooCommerce is online", "model_id": MODEL_ID}
+    return {"status": "Transparent Reasoning Agent for WordPress/WooCommerce is online", "model_id": MODEL_ID}