Update app.py

app.py

@@ -614,7 +614,7 @@ Your goal: Provide the EXACT answer in the EXACT format requested.
             chat_llm = ChatGroq(
                 temperature=0,  # Maximum determinism
                 groq_api_key=GROQ_API_KEY,
-                model_name="llama-3.3-70b-versatile",  # Best reasoning model
+                model_name="qwen/qwen3-32b",  # Best reasoning model
                 max_tokens=4096,
                 timeout=60
             )
@@ -651,35 +651,102 @@ Your goal: Provide the EXACT answer in the EXACT format requested.
                         )
                         return {"messages": [error_msg], "turn": current_turn}
                     time.sleep(2 ** attempt)  # Exponential backoff
-            
-            # --- Fallback JSON parsing ---
+            # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+            # --- ADD THIS RULE ENFORCEMENT BLOCK ---
+            #
+            # Force compliance with the "Plan on Turn 1" rule.
+            # If the agent tries to call a tool on turn 1, we
+            # strip the tool call and send a correction message.
+            if current_turn == 1 and ai_message.tool_calls:
+                print("⚠️ AGENT VIOLATION: Tried to call tools on Turn 1. Forcing replan.")
+                
+                # Strip the illegal tool call
+                ai_message.tool_calls = []
+                
+                # Create a correction message
+                correction_message = SystemMessage(
+                    content="SYSTEM: Protocol Violation. Your FIRST turn MUST be a plan with NO tool calls. "
+                            "You are not allowed to call any tools on your first turn. "
+                            "Re-read the protocol and provide your 2-3 sentence plan now."
+                )
+                
+                # Return the (now harmless) AI message + the correction
+                return {"messages": [ai_message, correction_message], "turn": current_turn}
+            # --- END OF RULE ENFORCEMENT BLOCK ---
+# +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+            # --- FIX #2: REPLACE THE FALLBACK PARSING BLOCK ---
+            #
+            # --- Fallback Parsing ---
+            # Check if LLM failed to format tool call and put it in 'content'
             if not ai_message.tool_calls and isinstance(ai_message.content, str) and ai_message.content.strip():
-                json_match = re.search(
-                    r"```(?:json)?\s*(\{.*?\})\s*```|(\{.*?\})", 
-                    ai_message.content, 
+                content = ai_message.content
+                tool_name = None
+                tool_input = None
+                
+                # 1. Try to parse the new <function(tool_name)>{json}</function> format
+                # Note: We look for </function> optionally, as it might be truncated
+                func_match = re.search(
+                    r"<function\(([^)]+)\)>(\{.*?\})(?:</function>)?",
+                    content,
                     re.DOTALL | re.IGNORECASE
                 )
                 
-                if json_match:
-                    json_str = json_match.group(1) or json_match.group(2)
+                if func_match:
                     try:
-                        parsed_json = json.loads(json_str)
-                        if isinstance(parsed_json, dict) and "tool" in parsed_json and "tool_input" in parsed_json:
-                            tool_name = parsed_json.get("tool")
-                            tool_input = parsed_json.get("tool_input", {})
-                            
-                            if any(t.name == tool_name for t in self.tools):
-                                print(f"🔧 Fallback: Parsed tool call for '{tool_name}' from JSON in content")
-                                tool_call = ToolCall(
-                                    name=tool_name, 
-                                    args=tool_input, 
-                                    id=str(uuid.uuid4())
-                                )
-                                ai_message.tool_calls = [tool_call]
-                                ai_message.content = ""
-                    except json.JSONDecodeError:
-                        pass
-            
+                        tool_name = func_match.group(1).strip()
+                        json_str = func_match.group(2)
+                        tool_input = json.loads(json_str)
+                        print(f"🔧 Fallback (Format 1): Parsed tool call for '{tool_name}'")
+                    except json.JSONDecodeError as e:
+                        print(f"⚠️ Fallback (Format 1): Failed to parse JSON: {e}")
+                        tool_name = None # Reset
+                
+                # 2. If Format 1 failed, try to parse bare JSON (old fallback)
+                if not tool_name:
+                    json_match = re.search(
+                        r"```(?:json)?\s*(\{.*?\})\s*```|(\{.*?\})", 
+                        content, 
+                        re.DOTALL | re.IGNORECASE
+                    )
+                    if json_match:
+                        json_str = json_match.group(1) or json_match.group(2)
+                        try:
+                            parsed_json = json.loads(json_str)
+                            # This format is less structured; we guess tool from keys
+                            if isinstance(parsed_json, dict):
+                                if "tool" in parsed_json and "tool_input" in parsed_json:
+                                    tool_name = parsed_json.get("tool")
+                                    tool_input = parsed_json.get("tool_input", {})
+                                elif "code" in parsed_json: # Guess code_interpreter
+                                    tool_name = "code_interpreter"
+                                    tool_input = parsed_json
+                                elif "answer" in parsed_json: # Guess final_answer
+                                    tool_name = "final_answer_tool"
+                                    tool_input = parsed_json
+                                
+                                if tool_name:
+                                    print(f"🔧 Fallback (Format 2): Parsed tool call for '{tool_name}'")
+
+                        except json.JSONDecodeError as e:
+                             print(f"⚠️ Fallback (Format 2): Failed to parse JSON: {e}")
+
+                # --- If any fallback parser succeeded, build the tool call ---
+                if tool_name and tool_input is not None and any(t.name == tool_name for t in self.tools):
+                    print(f"🔧 Fallback SUCCESS: Rebuilding tool call for '{tool_name}'")
+                    tool_call = ToolCall(
+                        name=tool_name, 
+                        args=tool_input, 
+                        id=str(uuid.uuid4())
+                    )
+                    ai_message.tool_calls = [tool_call]
+                    ai_message.content = "" # Clear content field
+                
+                elif not tool_name:
+                    print(f"⚠️ Fallback FAILED: Could not parse any tool call from content:\n{content[:200]}...")
+            # --- END OF REPLACEMENT BLOCK ---
+            # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+
             # --- Logging ---
             if ai_message.tool_calls:
                 for tc in ai_message.tool_calls: