Update app.py

app.py

@@ -1,70 +1,493 @@
+import os
+import re
+import json
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
-
-    messages = [{"role": "system", "content": system_message}]
-
-    messages.extend(history)
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    type="messages",
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
+from typing import List, Dict, Any, Generator
+import requests
+from datetime import datetime
+import ast
+import operator as op
+import wikipedia
 
+# Tool implementations
+class Tool:
+    def __init__(self, name: str, description: str, func):
+        self.name = name
+        self.description = description
+        self.func = func
+    
+    def __call__(self, *args, **kwargs):
+        return self.func(*args, **kwargs)
+
+def duckduckgo_search(query: str) -> str:
+    """Search DuckDuckGo for information."""
+    try:
+        url = "https://api.duckduckgo.com/"
+        params = {
+            'q': query,
+            'format': 'json',
+            'no_html': 1,
+            'skip_disambig': 1
+        }
+        response = requests.get(url, params=params, timeout=10)
+        data = response.json()
+        
+        # Get abstract or first related topic
+        if data.get('Abstract'):
+            return f"Search result: {data['Abstract']}"
+        elif data.get('RelatedTopics') and len(data['RelatedTopics']) > 0:
+            results = []
+            for topic in data['RelatedTopics'][:3]:
+                if 'Text' in topic:
+                    results.append(topic['Text'])
+            return f"Search results: {' | '.join(results)}" if results else "No results found."
+        else:
+            return "No results found."
+    except Exception as e:
+        return f"Search error: {str(e)}"
+
+def wikipedia_search(query: str) -> str:
+    """Search Wikipedia for information."""
+    try:
+        wikipedia.set_lang("en")
+        # Get summary
+        summary = wikipedia.summary(query, sentences=3, auto_suggest=True)
+        return f"Wikipedia: {summary}"
+    except wikipedia.exceptions.DisambiguationError as e:
+        return f"Wikipedia: Multiple results found. Please be more specific. Options: {', '.join(e.options[:5])}"
+    except wikipedia.exceptions.PageError:
+        return f"Wikipedia: No page found for '{query}'."
+    except Exception as e:
+        return f"Wikipedia error: {str(e)}"
+
+def get_weather(location: str) -> str:
+    """Get current weather for a location using wttr.in."""
+    try:
+        url = f"https://wttr.in/{location}?format=j1"
+        response = requests.get(url, timeout=10)
+        data = response.json()
+        
+        current = data['current_condition'][0]
+        temp_c = current['temp_C']
+        temp_f = current['temp_F']
+        desc = current['weatherDesc'][0]['value']
+        humidity = current['humidity']
+        wind_speed = current['windspeedKmph']
+        
+        return f"Weather in {location}: {desc}, {temp_c}°C ({temp_f}°F), Humidity: {humidity}%, Wind: {wind_speed} km/h"
+    except Exception as e:
+        return f"Weather error: {str(e)}"
+
+def calculate(expression: str) -> str:
+    """Safely evaluate mathematical expressions."""
+    # Supported operators
+    operators = {
+        ast.Add: op.add,
+        ast.Sub: op.sub,
+        ast.Mult: op.mul,
+        ast.Div: op.truediv,
+        ast.Pow: op.pow,
+        ast.USub: op.neg,
+        ast.Mod: op.mod,
+    }
+    
+    def eval_expr(node):
+        if isinstance(node, ast.Num):
+            return node.n
+        elif isinstance(node, ast.BinOp):
+            return operators[type(node.op)](eval_expr(node.left), eval_expr(node.right))
+        elif isinstance(node, ast.UnaryOp):
+            return operators[type(node.op)](eval_expr(node.operand))
+        elif isinstance(node, ast.Call):
+            # Support basic math functions
+            if node.func.id == 'abs':
+                return abs(eval_expr(node.args[0]))
+            elif node.func.id == 'round':
+                return round(eval_expr(node.args[0]))
+        else:
+            raise TypeError(node)
+    
+    try:
+        # Clean the expression
+        expression = expression.strip()
+        # Parse and evaluate
+        node = ast.parse(expression, mode='eval')
+        result = eval_expr(node.body)
+        return f"Result: {result}"
+    except Exception as e:
+        return f"Calculation error: {str(e)}. Please use basic arithmetic operators (+, -, *, /, **, %)."
+
+def python_repl(code: str) -> str:
+    """Execute safe Python code (limited to basic operations)."""
+    try:
+        # Whitelist of safe builtins
+        safe_builtins = {
+            'abs': abs, 'round': round, 'min': min, 'max': max,
+            'sum': sum, 'len': len, 'range': range, 'list': list,
+            'dict': dict, 'str': str, 'int': int, 'float': float,
+            'print': print, 'enumerate': enumerate, 'zip': zip,
+            'sorted': sorted, 'reversed': reversed,
+        }
+        
+        # Create restricted namespace
+        namespace = {'__builtins__': safe_builtins}
+        
+        # Capture output
+        from io import StringIO
+        import sys
+        old_stdout = sys.stdout
+        sys.stdout = StringIO()
+        
+        # Execute code
+        exec(code, namespace)
+        
+        # Get output
+        output = sys.stdout.getvalue()
+        sys.stdout = old_stdout
+        
+        # Also get any variables that were set
+        result_vars = {k: v for k, v in namespace.items() if k != '__builtins__' and not k.startswith('_')}
+        
+        result = output if output else str(result_vars) if result_vars else "Code executed successfully (no output)"
+        return f"Python output: {result}"
+    except Exception as e:
+        return f"Python error: {str(e)}"
+
+# Define tools
+TOOLS = [
+    Tool(
+        name="duckduckgo_search",
+        description="Search the web using DuckDuckGo. Use this when you need current information or facts. Input should be a search query string.",
+        func=duckduckgo_search
+    ),
+    Tool(
+        name="wikipedia_search",
+        description="Search Wikipedia for detailed information about topics, people, places, etc. Input should be a search query string.",
+        func=wikipedia_search
+    ),
+    Tool(
+        name="get_weather",
+        description="Get current weather information for a location. Input should be a city name or location string.",
+        func=get_weather
+    ),
+    Tool(
+        name="calculate",
+        description="Perform mathematical calculations. Input should be a mathematical expression like '5 + 3 * 2' or '2 ** 10'.",
+        func=calculate
+    ),
+    Tool(
+        name="python_repl",
+        description="Execute Python code for data processing or calculations. Input should be valid Python code. Only basic operations are allowed.",
+        func=python_repl
+    ),
+]
+
+# Create tool descriptions for prompt
+def get_tool_descriptions() -> str:
+    descriptions = []
+    for tool in TOOLS:
+        descriptions.append(f"- {tool.name}: {tool.description}")
+    return "\n".join(descriptions)
+
+# Agent prompts
+THINK_ONLY_PROMPT = """You are a helpful AI assistant. You solve problems by thinking through them step-by-step.
+
+For each question:
+1. Think through the problem carefully in your internal monologue
+2. Show your reasoning process using "Thought: ..." format
+3. Provide a final answer using "Answer: ..." format
+
+You do NOT have access to any tools. Rely only on your knowledge and reasoning.
+
+Question: {question}
+
+Let's think step by step:"""
+
+ACT_ONLY_PROMPT = """You are a helpful AI assistant with access to tools. You solve problems by using tools.
+
+Available tools:
+{tools}
+
+For each question, you must use tools to find information. Do NOT think or reason - just use tools.
+
+Format your response as:
+Action: tool_name
+Action Input: input_for_tool
+
+After receiving the observation, you can call another tool or provide the final answer:
+Answer: your final answer
+
+Question: {question}
+
+Action:"""
+
+REACT_PROMPT = """You are a helpful AI assistant that can think and use tools. You solve problems by alternating between Thought, Action, and Observation.
+
+Available tools:
+{tools}
+
+For each question, follow this pattern:
+Thought: Think about what you need to do next
+Action: tool_name
+Action Input: input_for_tool
+Observation: [tool result will be provided]
+... (repeat Thought/Action/Observation as needed)
+Thought: I now know the final answer
+Answer: your final answer
+
+Question: {question}
+
+Thought:"""
+
+def parse_action(text: str) -> tuple:
+    """Parse action and action input from model output."""
+    action_pattern = r'Action:\s*(\w+)'
+    input_pattern = r'Action Input:\s*(.+?)(?=\n(?:Thought:|Action:|Answer:|$))'
+    
+    action_match = re.search(action_pattern, text, re.IGNORECASE)
+    input_match = re.search(input_pattern, text, re.IGNORECASE | re.DOTALL)
+    
+    if action_match and input_match:
+        action_name = action_match.group(1).strip()
+        action_input = input_match.group(1).strip()
+        return action_name, action_input
+    return None, None
+
+def call_tool(tool_name: str, tool_input: str) -> str:
+    """Call a tool by name."""
+    for tool in TOOLS:
+        if tool.name.lower() == tool_name.lower():
+            return tool(tool_input)
+    return f"Error: Tool '{tool_name}' not found. Available tools: {', '.join([t.name for t in TOOLS])}"
+
+def call_llm(messages: List[Dict], temperature: float = 0.7, max_tokens: int = 500) -> str:
+    """Call the LLM API."""
+    try:
+        api_key = os.environ.get("HF_TOKEN")
+        if not api_key:
+            return "Error: HF_TOKEN not found. Please set your Hugging Face token."
+        
+        url = "https://api-inference.huggingface.co/models/openai/gpt-oss-20b/v1/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "model": "openai/gpt-oss-20b",
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": False
+        }
+        
+        response = requests.post(url, headers=headers, json=payload, timeout=30)
+        
+        if response.status_code == 200:
+            result = response.json()
+            return result['choices'][0]['message']['content']
+        else:
+            return f"API Error {response.status_code}: {response.text}"
+    except Exception as e:
+        return f"Error calling LLM: {str(e)}"
+
+def think_only_mode(question: str) -> Generator[str, None, None]:
+    """Think-Only mode: Chain-of-Thought only, no tools."""
+    prompt = THINK_ONLY_PROMPT.format(question=question)
+    messages = [{"role": "user", "content": prompt}]
+    
+    yield "**Mode: Think-Only (Chain-of-Thought)**\n\n"
+    yield "🤔 Generating thoughts...\n\n"
+    
+    response = call_llm(messages, temperature=0.7, max_tokens=800)
+    
+    # Parse and format the response
+    lines = response.split('\n')
+    for line in lines:
+        if line.strip():
+            if line.strip().startswith('Thought:'):
+                yield f"**{line.strip()}**\n\n"
+            elif line.strip().startswith('Answer:'):
+                yield f"**{line.strip()}**\n\n"
+            else:
+                yield f"{line}\n\n"
+    
+    yield "\n---\n**Mode completed**\n"
+
+def act_only_mode(question: str, max_iterations: int = 5) -> Generator[str, None, None]:
+    """Act-Only mode: Tool use only, no explicit thinking."""
+    tool_descriptions = get_tool_descriptions()
+    prompt = ACT_ONLY_PROMPT.format(question=question, tools=tool_descriptions)
+    
+    yield "**Mode: Act-Only (Tool Use Only)**\n\n"
+    
+    messages = [{"role": "user", "content": prompt}]
+    iteration = 0
+    
+    while iteration < max_iterations:
+        iteration += 1
+        
+        response = call_llm(messages, temperature=0.5, max_tokens=300)
+        
+        # Check for final answer
+        if 'Answer:' in response:
+            answer_match = re.search(r'Answer:\s*(.+)', response, re.IGNORECASE | re.DOTALL)
+            if answer_match:
+                yield f"**Answer:** {answer_match.group(1).strip()}\n\n"
+                break
+        
+        # Parse action
+        action_name, action_input = parse_action(response)
+        
+        if action_name and action_input:
+            yield f"**Action:** {action_name}\n"
+            yield f"**Action Input:** {action_input}\n\n"
+            
+            # Execute tool
+            observation = call_tool(action_name, action_input)
+            yield f"**Observation:** {observation}\n\n"
+            
+            # Add to conversation
+            messages.append({"role": "assistant", "content": response})
+            messages.append({"role": "user", "content": f"Observation: {observation}\n\nContinue with another action or provide the final answer."})
+        else:
+            yield f"⚠️ Could not parse action from response. Response: {response}\n\n"
+            break
+    
+    if iteration >= max_iterations:
+        yield "⚠️ **Reached maximum iterations.**\n\n"
+    
+    yield "\n---\n**Mode completed**\n"
+
+def react_mode(question: str, max_iterations: int = 5) -> Generator[str, None, None]:
+    """ReAct mode: Interleaving Thought, Action, Observation."""
+    tool_descriptions = get_tool_descriptions()
+    prompt = REACT_PROMPT.format(question=question, tools=tool_descriptions)
+    
+    yield "**Mode: ReAct (Thought + Action + Observation)**\n\n"
+    
+    messages = [{"role": "user", "content": prompt}]
+    iteration = 0
+    
+    while iteration < max_iterations:
+        iteration += 1
+        
+        response = call_llm(messages, temperature=0.7, max_tokens=400)
+        
+        # Parse thoughts
+        thought_matches = re.findall(r'Thought:\s*(.+?)(?=\n(?:Action:|Answer:|$))', response, re.IGNORECASE | re.DOTALL)
+        for thought in thought_matches:
+            yield f" **Thought:** {thought.strip()}\n\n"
+        
+        # Check for final answer
+        if 'Answer:' in response:
+            answer_match = re.search(r'Answer:\s*(.+)', response, re.IGNORECASE | re.DOTALL)
+            if answer_match:
+                yield f"**Answer:** {answer_match.group(1).strip()}\n\n"
+                break
+        
+        # Parse action
+        action_name, action_input = parse_action(response)
+        
+        if action_name and action_input:
+            yield f"**Action:** {action_name}\n"
+            yield f"**Action Input:** {action_input}\n\n"
+            
+            # Execute tool
+            observation = call_tool(action_name, action_input)
+            yield f"**Observation:** {observation}\n\n"
+            
+            # Add to conversation
+            messages.append({"role": "assistant", "content": response})
+            messages.append({"role": "user", "content": f"Observation: {observation}\n\nThought:"})
+        else:
+            # If no action but also no answer, there might be an issue
+            if 'Answer:' not in response:
+                yield f"⚠️ No action found. Response: {response}\n\n"
+            break
+    
+    if iteration >= max_iterations:
+        yield "⚠️ **Reached maximum iterations.**\n\n"
+    
+    yield "\n---\n**Mode completed**\n"
+
+# Example questions
+EXAMPLES = [
+    "What is the capital of France and what's the current weather there?",
+    "Who wrote 'To Kill a Mockingbird' and when was it published?",
+    "Calculate the compound interest on $1000 at 5% annual rate for 3 years using the formula A = P(1 + r)^t",
+    "What is the population of Tokyo and how does it compare to New York City?",
+    "If I have a list of numbers [15, 23, 8, 42, 16], what is the average and which number is closest to it?",
+    "What are the main causes of climate change according to scientific consensus?",
+]
+
+def run_comparison(question: str, mode: str):
+    """Run the selected mode(s)."""
+    if mode == "Think-Only":
+        return think_only_mode(question), "", ""
+    elif mode == "Act-Only":
+        return "", act_only_mode(question), ""
+    elif mode == "ReAct":
+        return "", "", react_mode(question)
+    elif mode == "All (Compare)":
+        return think_only_mode(question), act_only_mode(question), react_mode(question)
+    else:
+        return "Invalid mode selected.", "", ""
+
+# Gradio Interface
+with gr.Blocks(title="LLM Reasoning Modes Comparison", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # LLM Reasoning Modes Comparison
+    
+    Compare three reasoning approaches using **openai/gpt-oss-20b**:
+    
+    - **Think-Only**: Chain-of-Thought reasoning only (no tools)
+    - **Act-Only**: Tool use only (no explicit reasoning)
+    - **ReAct**: Interleaved Thought → Action → Observation
+    
+    ### Available Tools:
+    DuckDuckGo Search | Wikipedia | Weather API | Calculator | Python REPL
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            question_input = gr.Textbox(
+                label="Enter your question",
+                placeholder="Ask a question that might require tools or reasoning...",
+                lines=3
+            )
+            mode_dropdown = gr.Dropdown(
+                choices=["Think-Only", "Act-Only", "ReAct", "All (Compare)"],
+                value="All (Compare)",
+                label="Select Mode"
+            )
+            submit_btn = gr.Button("Run", variant="primary", size="lg")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### Example Questions")
+            for idx, example in enumerate(EXAMPLES):
+                gr.Button(f"Ex {idx+1}", size="sm").click(
+                    fn=lambda ex=example: ex,
+                    outputs=question_input
+                )
+    
+    gr.Markdown("---")
+    
+    with gr.Row():
+        with gr.Column():
+            think_output = gr.Markdown(label="Think-Only Output")
+        with gr.Column():
+            act_output = gr.Markdown(label="Act-Only Output")
+        with gr.Column():
+            react_output = gr.Markdown(label="ReAct Output")
+    
+    submit_btn.click(
+        fn=run_comparison,
+        inputs=[question_input, mode_dropdown],
+        outputs=[think_output, act_output, react_output]
+    )
+    
 
 if __name__ == "__main__":
     demo.launch()
+