Initial ReAct Space: Compare Think-Only, Act-Only, and ReAct reasoning modes

ARCHITECTURE.md

@@ -0,0 +1,268 @@
+# 🏗️ Architecture Overview
+
+## System Architecture
+
+This Hugging Face Space implements a comparative agent system with three reasoning modes. Here's how everything works together:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Gradio UI Layer                          │
+│  - Question Input                                           │
+│  - Mode Selection (Think/Act/ReAct/All)                    │
+│  - Three Output Panels (side-by-side comparison)           │
+└──────────────────┬──────────────────────────────────────────┘
+                   │
+                   ▼
+┌─────────────────────────────────────────────────────────────┐
+│                   Agent Controller                          │
+│  run_comparison() - Routes to appropriate mode handler     │
+└──────────────────┬──────────────────────────────────────────┘
+                   │
+        ┌──────────┴──────────┬──────────────┐
+        ▼                     ▼              ▼
+┌──────────────┐    ┌──────────────┐    ┌──────────────┐
+│  Think-Only  │    │   Act-Only   │    │    ReAct     │
+│    Mode      │    │     Mode     │    │     Mode     │
+└──────┬───────┘    └──────┬───────┘    └──────┬───────┘
+       │                   │                    │
+       ▼                   ▼                    ▼
+┌─────────────────────────────────────────────────────────────┐
+│                    LLM Interface                            │
+│  call_llm() - Communicates with openai/gpt-oss-20b        │
+└──────────────────┬──────────────────────────────────────────┘
+                   │
+                   ▼ (Act-Only & ReAct modes only)
+┌─────────────────────────────────────────────────────────────┐
+│                    Tool Executor                            │
+│  - parse_action()                                           │
+│  - call_tool()                                              │
+└──────────────────┬──────────────────────────────────────────┘
+                   │
+       ┌───────────┴───────────┬───────────┬───────────┬──────┐
+       ▼                       ▼           ▼           ▼      ▼
+┌────────────┐  ┌────────────┐  ┌──────┐  ┌────┐  ┌─────────┐
+│ DuckDuckGo │  │ Wikipedia  │  │Weather│ │Calc│  │ Python  │
+│   Search   │  │   Search   │  │  API  │ │    │  │  REPL   │
+└────────────┘  └────────────┘  └──────┘  └────┘  └─────────┘
+```
+
+## Component Details
+
+### 1. **Tool Layer**
+
+Each tool is wrapped in a `Tool` class with:
+- **name**: Identifier for the LLM to reference
+- **description**: Instructions for when/how to use the tool
+- **func**: The actual implementation
+
+**Tool Implementations:**
+
+- `duckduckgo_search()`: Uses DuckDuckGo's JSON API
+- `wikipedia_search()`: Uses the Wikipedia Python library
+- `get_weather()`: Queries wttr.in API for weather data
+- `calculate()`: Safe AST-based math expression evaluator
+- `python_repl()`: Sandboxed Python execution with whitelisted builtins
+
+### 2. **Agent Modes**
+
+#### Think-Only Mode (`think_only_mode`)
+```
+User Question → System Prompt → LLM → Thoughts → Answer
+```
+- Single LLM call with CoT prompt
+- No tool access
+- Shows reasoning steps
+- Best for knowledge-based questions
+
+#### Act-Only Mode (`act_only_mode`)
+```
+User Question → System Prompt → LLM → Action
+                                   ↓
+                            Execute Tool → Observation
+                                   ↓
+                                  LLM → Action/Answer
+                                   ↓
+                                  ...
+```
+- Iterative loop: Action → Observation
+- No explicit "Thought" step
+- Maximum 5 iterations
+- Best for information gathering
+
+#### ReAct Mode (`react_mode`)
+```
+User Question → System Prompt → LLM → Thought → Action
+                                         ↓
+                                  Execute Tool → Observation
+                                         ↓
+                                       LLM → Thought → Action/Answer
+                                         ↓
+                                        ...
+```
+- Full Thought-Action-Observation cycle
+- Most comprehensive reasoning
+- Maximum 5 iterations
+- Best for complex multi-step problems
+
+### 3. **LLM Interface**
+
+**`call_llm()` Function:**
+- Uses Hugging Face Inference API
+- Model: openai/gpt-oss-20b
+- Supports chat format (messages list)
+- Configurable temperature and max_tokens
+
+**Authentication:**
+- Requires `HF_TOKEN` environment variable
+- Set in Space secrets (secure)
+
+### 4. **Parsing & Control Flow**
+
+**`parse_action()` Function:**
+- Extracts `Action:` and `Action Input:` from LLM response
+- Uses regex to handle various formats
+- Returns (action_name, action_input) tuple
+
+**Iteration Control:**
+- Max 5 iterations per mode to prevent infinite loops
+- Early termination when "Answer:" detected
+- Error handling for malformed responses
+
+### 5. **UI Layer (Gradio)**
+
+**Components:**
+- **Input Section**: Question textbox + mode dropdown
+- **Example Buttons**: Pre-filled question templates
+- **Output Panels**: Three side-by-side Markdown displays
+- **Streaming**: Generator functions for real-time updates
+
+**User Flow:**
+1. User enters question or clicks example
+2. Selects mode (or "All" for comparison)
+3. Clicks "Run"
+4. Sees real-time updates in output panel(s)
+5. Views final answer and complete reasoning trace
+
+## Data Flow Example
+
+### Example: "What's the weather in Paris?"
+
+**Mode: ReAct**
+
+1. User submits question
+2. `react_mode()` called with question
+3. Prompt formatted with question + tool descriptions
+4. First LLM call:
+   ```
+   Thought: I need to check the current weather in Paris
+   Action: get_weather
+   Action Input: Paris
+   ```
+5. `parse_action()` extracts tool call
+6. `call_tool("get_weather", "Paris")` executes
+7. Observation: "Weather in Paris: Cloudy, 15°C..."
+8. Second LLM call with observation
+9. LLM responds:
+   ```
+   Thought: I have the weather information
+   Answer: The current weather in Paris is...
+   ```
+10. Generator yields formatted output to UI
+11. User sees complete trace in ReAct panel
+
+## Key Design Patterns
+
+### 1. **Generator Pattern for Streaming**
+```python
+def mode(question: str) -> Generator[str, None, None]:
+    yield "Step 1..."
+    # process
+    yield "Step 2..."
+    # etc
+```
+Enables real-time UI updates without blocking
+
+### 2. **Tool Registry Pattern**
+```python
+TOOLS = [Tool(name, description, func), ...]
+```
+Easy to add new tools - just append to list
+
+### 3. **Prompt Templates**
+```python
+PROMPT = """...""".format(question=q, tools=t)
+```
+Modular prompts for each mode
+
+### 4. **Safe Execution**
+- AST parsing for calculator (no `eval()`)
+- Whitelisted builtins for Python REPL
+- Timeout limits on API calls
+- Error handling with fallback messages
+
+## Extensibility
+
+### Adding a New Tool
+
+```python
+def my_tool(input: str) -> str:
+    # Implementation
+    return result
+
+TOOLS.append(Tool(
+    name="my_tool",
+    description="When to use this tool...",
+    func=my_tool
+))
+```
+
+### Adding a New Mode
+
+```python
+def hybrid_mode(question: str) -> Generator[str, None, None]:
+    # Custom logic mixing elements
+    yield "Starting hybrid mode..."
+    # ...
+    
+# Add to run_comparison() and UI dropdown
+```
+
+### Customizing Prompts
+
+Edit the `*_PROMPT` constants to change agent behavior:
+- Add constraints
+- Change format
+- Provide examples
+- Adjust tone
+
+## Performance Considerations
+
+1. **API Latency**: Model calls take 2-5 seconds
+2. **Tool Latency**: External APIs add 1-2 seconds per call
+3. **Iteration Count**: 5 iterations max = ~30 seconds worst case
+4. **Parallel Modes**: "All" mode runs sequentially (not parallel)
+
+## Security Notes
+
+1. **API Keys**: Never commit `HF_TOKEN` to repo
+2. **Python REPL**: Sandboxed with limited builtins
+3. **User Input**: Sanitized before tool execution
+4. **Rate Limits**: Consider adding rate limiting for production
+
+## Testing Strategy
+
+1. **Unit Tests**: Test individual tool functions
+2. **Integration Tests**: Test mode handlers end-to-end
+3. **Prompt Tests**: Verify LLM responses parse correctly
+4. **UI Tests**: Test Gradio interface components
+
+## Future Enhancements
+
+- [ ] Add memory/conversation history
+- [ ] Implement parallel tool calling
+- [ ] Add caching layer for repeated queries
+- [ ] Support custom user tools
+- [ ] Add performance metrics/timing
+- [ ] Implement token counting/cost tracking
+- [ ] Add export functionality for reasoning traces
+

README.md

@@ -0,0 +1,86 @@
+---
+title: ReAct - Reasoning Modes Comparison
+emoji: 🧠
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🧠 LLM Reasoning Modes Comparison
+
+This Space demonstrates and compares three different reasoning paradigms for Large Language Models using **openai/gpt-oss-20b**:
+
+## 🎯 Reasoning Modes
+
+### 1. **Think-Only** (Chain-of-Thought)
+- Uses internal reasoning and knowledge only
+- Shows step-by-step thought process
+- No external tool access
+- Best for: Problems solvable with general knowledge
+
+### 2. **Act-Only** (Tool Use)
+- Uses external tools to gather information
+- Shows actions and observations only
+- Minimal explicit reasoning
+- Best for: Fact-checking and real-time data retrieval
+
+### 3. **ReAct** (Reasoning + Acting)
+- Interleaves Thought → Action → Observation
+- Combines reasoning with tool use
+- Most comprehensive approach
+- Best for: Complex problems requiring both reasoning and external data
+
+## 🛠️ Available Tools
+
+The agent has access to these real external tools:
+
+- **🔍 DuckDuckGo Search**: Web search for current information
+- **📚 Wikipedia Search**: Detailed encyclopedic knowledge
+- **🌤️ Weather API**: Real-time weather data for any location
+- **🧮 Calculator**: Safe mathematical expression evaluation
+- **🐍 Python REPL**: Execute Python code for data processing
+
+## 🚀 How to Use
+
+1. Enter your question in the text box
+2. Select a reasoning mode (or "All" to compare)
+3. Click "Run" to see the agent work in real-time
+4. Watch as thoughts, actions, and observations unfold
+
+## 📝 Example Questions
+
+- "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"
+- "What is the population of Tokyo and how does it compare to New York City?"
+
+## 🔧 Setup
+
+To run this Space, you need to set your Hugging Face token:
+
+1. Go to Space Settings → Repository Secrets
+2. Add a secret named `HF_TOKEN` with your Hugging Face API token
+3. The Space will automatically use this token to access the model
+
+## 📚 Technical Details
+
+- **Model**: openai/gpt-oss-20b (via Hugging Face Inference API)
+- **Framework**: Gradio for the UI
+- **Agent Format**: Inspired by smolagents/ReAct paradigm
+- **Streaming**: Real-time display of intermediate steps
+
+## 🎓 Learn More
+
+This implementation demonstrates the ReAct (Reason + Act) paradigm described in:
+- Yao et al. (2022) "ReAct: Synergizing Reasoning and Acting in Language Models"
+
+The three modes show how different combinations of reasoning and tool use affect problem-solving capabilities.
+
+## 📄 License
+
+MIT License - feel free to use and modify!
+

app.py

@@ -0,0 +1,503 @@
+import os
+import re
+import json
+import gradio as gr
+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]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### 📖 About
+    This Space demonstrates three reasoning paradigms:
+    - **Think-Only** relies on the model's internal knowledge and reasoning
+    - **Act-Only** uses external tools without explicit reasoning steps
+    - **ReAct** combines reasoning and acting for more robust problem-solving
+    
+    *Note: Set your HF_TOKEN in Space secrets to use the model.*
+    """)
+
+if __name__ == "__main__":
+    demo.launch()
+

requirements.txt

@@ -0,0 +1,5 @@
+gradio==4.44.0
+requests==2.31.0
+wikipedia-api==0.6.0
+wikipedia==1.4.0
+