Update app.py

app.py

@@ -577,50 +577,39 @@ Your goal: Provide the EXACT answer in the EXACT format requested.
 
 1. **ANALYZE QUESTION:**
    - What information is needed?
-   - What format should the answer be?
-   - Are there any files?
+   - What format should the answer be? (number, list, yes/no, name, etc.)
+   - Are there any files attached?
 
 2. **FIRST TURN - MAKE A PLAN:**
-   - Your FIRST response MUST be a brief plan (2-3 sentences).
-   - DO NOT call tools on your first turn! Just state the plan.
+   Your FIRST response MUST be a brief plan (2-3 sentences):
+   - What tools you'll use
+   - What order you'll use them
+   - What format the final answer should be
+   DO NOT call tools on your first turn!
 
 3. **EXECUTE:**
-   - Call ONE tool per turn.
-   - Wait for the result before planning your next step.
+   - Call ONE tool per turn
+   - Wait for the result before planning your next step
    - For ANY calculation or logic: use code_interpreter with print()
 
 4. **VERIFY RESULTS:**
-   - Check if tool output contains errors.
-   - If error: plan a different approach.
-   - If success: decide if you need more info or have the answer.
+   - Check if tool output contains errors
+   - If error: plan a different approach
+   - If success: decide if you need more info or have the answer
 
 5. **FINISH:**
-   - When you have the answer from a tool output:
-   - Call final_answer_tool immediately.
+   When you have the answer from a tool output:
+   - Call final_answer_tool immediately
    - Provide ONLY the exact answer (no explanations!)
 
 **CRITICAL RULES:**
 
-❌ NEVER guess or use training data.
-❌ NEVER call multiple tools in one turn.
-❌ NEVER add explanations to final_answer_tool.
-✅ ALWAYS use code_interpreter for calculations/logic.
-✅ ALWAYS match the requested answer format exactly.
-✅ ALWAYS base your answer on tool outputs.
-
-**TOOL CALL FORMATTING (CRITICAL!):**
-When you call a tool, you MUST use the exact tool name and provide arguments as valid JSON.
-
-**Example for final_answer_tool:**
-{{ "name": "final_answer_tool", "arguments": {{"answer": "The Final Answer"}} }}
-
-**Example for code_interpreter (MUST have 'code' key):**
-{{ "name": "code_interpreter", "arguments": {{"code": "print(1 + 1)"}} }}
-
-**Example for search_tool (MUST have 'query' key):**
-{{ "name": "search_tool", "arguments": {{"query": "latest news"}} }}
-
-Failure to provide arguments in this exact JSON format will cause an error.
+❌ NEVER guess or use training data for the final answer
+❌ NEVER call multiple tools in one turn
+❌ NEVER add explanations to final_answer_tool
+✅ ALWAYS use code_interpreter for calculations/logic
+✅ ALWAYS match the requested answer format exactly
+✅ ALWAYS base your answer on tool outputs, not memory
 
 **ANSWER FORMAT EXAMPLES:**
 - "What is 5+5?" → final_answer("10")
@@ -639,7 +628,7 @@ Failure to provide arguments in this exact JSON format will cause an error.
             chat_llm = ChatGroq(
                 temperature=0,  # Maximum determinism
                 groq_api_key=GROQ_API_KEY,
-                model_name="meta-llama/llama-4-scout-17b-16e-instruct",  # Best reasoning model
+                model_name="openai/gpt-oss-120b",  # Best reasoning model
                 max_tokens=4096,
                 timeout=60
             )
@@ -652,164 +641,116 @@ Failure to provide arguments in this exact JSON format will cause an error.
         print("✅ Tools bound to LLM")
         
         # --- Agent Node ---
+# --- Agent Node (v3 - Simplified) ---
         def agent_node(state: AgentState):
-                
-                # --- Turn Counter Logic ---
-                # We need to check if this is a retry of a failed turn (e.g., Turn 1 violation)
-                # We identify a retry if the *last* message was our "Protocol Violation" message
-                last_msg = state['messages'][-1]
-                is_a_retry = False
-                if isinstance(last_msg, SystemMessage) and "Protocol Violation" in last_msg.content:
-                    is_a_retry = True
-                
-                # Get the state's current turn number
-                current_turn = state.get('turn', 0)
-                
-                # If this is NOT a retry, increment the turn.
-                # If it IS a retry, we *stay on the same turn number*
-                if not is_a_retry:
-                    current_turn += 1
-                
-                # Handle the very first run (where state['turn'] is 0)
-                if current_turn == 0:
-                    current_turn = 1
-                # --- End Turn Counter Logic ---
+            current_turn = state.get('turn', 0) + 1
+            print(f"\n{'='*60}")
+            print(f"AGENT TURN {current_turn}/{MAX_TURNS}")
+            print('='*60)
+            
+            messages_to_send = state["messages"]
+            
+            # Retry logic with exponential backoff
+            max_retries = 3
+            ai_message = None
+            
+            for attempt in range(max_retries):
+                try:
+                    ai_message = self.llm_with_tools.invoke(messages_to_send)
+                    break
+                except Exception as e:
+                    print(f"⚠️ LLM attempt {attempt+1}/{max_retries} failed: {e}")
+                    if attempt == max_retries - 1:
+                        error_msg = AIMessage(
+                            content=f"Error: LLM failed after {max_retries} attempts: {str(e)}"
+                        )
+                        return {"messages": [error_msg], "turn": current_turn}
+                    time.sleep(2 ** attempt)  # Exponential backoff
+            
 
-                print(f"\n{'='*60}")
-                print(f"AGENT TURN {current_turn}/{MAX_TURNS}")
-                if is_a_retry:
-                    print("--- (Re-trying after protocol violation) ---")
-                print('='*60)
-                
-                messages_to_send = state["messages"]
+            # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+            # --- ROBUST FALLBACK PARSING BLOCK ---
+            # (We still need this to catch malformed tool calls)
+            
+            if not ai_message.tool_calls and isinstance(ai_message.content, str) and ai_message.content.strip():
+                content = ai_message.content
+                tool_name = None
+                tool_input = None
                 
-                # Retry logic with exponential backoff
-                max_retries = 3
-                ai_message = None
+                # 1. Try to parse <function(tool_name)>{json}</function>
+                func_match = re.search(
+                    r"<function\(([^)]+)\)>(\{.*?\})(?:</function>)?",
+                    content,
+                    re.DOTALL | re.IGNORECASE
+                )
                 
-                for attempt in range(max_retries):
+                if func_match:
                     try:
-                        ai_message = self.llm_with_tools.invoke(messages_to_send)
-                        break
-                    except Exception as e:
-                        print(f"⚠️ LLM attempt {attempt+1}/{max_retries} failed: {e}")
-                        if attempt == max_retries - 1:
-                            error_msg = AIMessage(
-                                content=f"Error: LLM failed after {max_retries} attempts: {str(e)}"
-                            )
-                            return {"messages": [error_msg], "turn": current_turn}
-                        time.sleep(2 ** attempt)  # Exponential backoff
+                        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
                 
-                # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-                # --- (FIX #1) RULE ENFORCEMENT BLOCK ---
-                #
-                # If it's Turn 1 AND the agent tried to call tools, we reject it
-                # and force it to re-do Turn 1.
-                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 the correction message that forces the plan
-                    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 messages.
-                    # Critically, we set the state's turn counter back to 1.
-                    # This ensures the *next* run of this node is *still* Turn 1.
-                    return {"messages": [ai_message, correction_message], "turn": 1}
-                # --- 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():
-                    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,
+                # 2. If Format 1 failed, try to parse bare JSON
+                if not tool_name:
+                    json_match = re.search(
+                        r"```(?:json)?\s*(\{.*?\})\s*```|(\{.*?\})", 
+                        content, 
                         re.DOTALL | re.IGNORECASE
                     )
-                    
-                    if func_match:
+                    if json_match:
+                        json_str = json_match.group(1) or json_match.group(2)
                         try:
-                            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}'")
+                            parsed_json = json.loads(json_str)
+                            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:
+                                    tool_name = "code_interpreter"
+                                    tool_input = parsed_json
+                                elif "answer" in parsed_json:
+                                    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 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:
-                        print(f"🔧 Tool Call: {tc.get('name')}")
-                        print(f"   Args: {tc.get('args', {})}")
-                elif ai_message.content:
-                    content_preview = ai_message.content[:300]
-                    if len(ai_message.content) > 300:
-                        content_preview += "..."
-                    print(f"💭 Agent Reasoning:\n{content_preview}")
+                             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 = ""
                 
-                return {"messages": [ai_message], "turn": current_turn}
-        
+                elif not tool_name:
+                    # We still want to log if it's just dribbling text
+                    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:
+                    print(f"🔧 Tool Call: {tc.get('name')}")
+                    print(f" Args: {tc.get('args', {})}")
+            elif ai_message.content:
+                content_preview = ai_message.content[:300]
+                if len(ai_message.content) > 300:
+                    content_preview += "..."
+                print(f"💭 Agent Reasoning:\n{content_preview}")
+            
+            return {"messages": [ai_message], "turn": current_turn}
             # --- Tool Node ---
         tool_node = ToolNode(self.tools)