app.py

import os
import json
import gradio as gr
import requests
import inspect
import pandas as pd

# =============================================================================
# MODIFICHE APPORTATE PER RISOLVERE L'ERRORE "generate" NON TROVATO:
#
# PROBLEMA ORIGINALE: 
# - Il pipeline di Transformers non è direttamente compatibile con smolagents
# - CodeAgent si aspetta un'interfaccia specifica che pipeline non implementa
# - L'errore "generate" si verificava perché smolagents cercava metodi non presenti
#
# SOLUZIONE IMPLEMENTATA:
# - Creata classe SimpleLocalModel che fa da wrapper
# - Implementa l'interfaccia __call__() che smolagents si aspetta  
# - Gestisce la conversione dei messaggi e la generazione delle risposte
# - Fallback multipli: locale -> remoto -> fisso
# =============================================================================

from smolagents import CodeAgent, InferenceClientModel, VisitWebpageTool, PythonInterpreterTool, WebSearchTool, WikipediaSearchTool, FinalAnswerTool, Tool, tool
# Importazioni per modelli locali (SOLUZIONE per errore "generate"):
from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
from litellm import LiteLLM
import threading
import time

# (Keep Constants as is)
# --- Constants ---
DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"

@tool
def invert_sentence(sentence: str) -> str:
	"""
	Inverts the order of all characters in a sentence.
	Args:
		sentence (str): The sentence to invert.
	Returns:
		str: The sentence with characters in reverse order.
	"""
	return sentence[::-1]

# Wrapper semplificato per modelli locali
# NUOVO APPROCCIO: Questa classe risolve il problema dell'errore "generate" 
# creando un'interfaccia compatibile tra Transformers pipeline e smolagents
class SimpleLocalModel:
	"""Wrapper semplice per modelli Transformers locali."""
	
	def __init__(self, model_name="gpt2"):
		self.model_name = model_name
		self.pipeline = None
		self._load_model()
	
	def _load_model(self):
		"""Carica il modello locale."""
		try:
			print(f"Caricamento modello locale: {self.model_name}")
			self.pipeline = pipeline(
				"text-generation",
				model=self.model_name,
				# device=-1,  # Usa CPU
				return_full_text=False  # Restituisce solo il testo generato
			)
			print(f"✅ Modello {self.model_name} caricato")
		except Exception as e:
			print(f"❌ Errore caricamento modello: {e}")
			raise
	
	def __call__(self, messages, **kwargs):
		"""Genera risposta compatibile con smolagents."""
		try:
			# Estrai il prompt
			if isinstance(messages, list) and messages:
				prompt = messages[-1].get("content", "") if isinstance(messages[-1], dict) else str(messages[-1])
			else:
				prompt = str(messages)
			
			if not prompt.strip():
				return "Mi dispiace, non ho ricevuto una domanda."
			
			# Genera risposta
			result = self.pipeline(prompt, max_new_tokens=100, do_sample=True, temperature=0.7)
			
			if result and len(result) > 0:
				answer = result[0].get("generated_text", "").strip()
				return answer if answer else "Non sono riuscito a generare una risposta."
			else:
				return "Errore nella generazione della risposta."
				
		except Exception as e:
			print(f"Errore generazione: {e}")
			return f"Errore: {str(e)}"

# --- First Agent Definition ---
# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
class FirstAgent:
	### First Agent is the first attempt to develop an agent for the course. ###
	def __init__(self):
		# CODICE ORIGINALE COMMENTATO (che causava l'errore "generate"):
		# # Usa un modello Hugging Face gratuito
		# token = os.getenv(os.getenv("TOKEN_NAME"))
		# os.environ["HF_TOKEN"] = token
		# model = InferenceClientModel(
		#	 token=token
		# )

		# CODICE ORIGINALE COMMENTATO (approccio con pipeline non compatibile):
		# # Configurazione con fallback multipli
		# model = None
		# # Try 1: Modello locale via Transformers
		# try:
		#	model_id = "microsoft/Phi-4-mini-reasoning"
		#	tokenizer = AutoTokenizer.from_pretrained(model_id)
		#	model = AutoModelForCausalLM.from_pretrained(model_id) # ~500MB
		#	model = pipeline(
		#		task="text-generation",
		#		tokenizer=tokenizer,
		#		model=model
		#	)
		#	print(f"Using local {model_id} model")
		# except Exception as e:
		#	print(f"Local model failed: {e}")
		#	# Try 2: Modello remoto gratuito
		#	try:
		#		model = LiteLLM(
		#			model_id="groq/mixtral-8x7b-32768"  # Gratuito con registrazione
		#		)
		#		print("Using Groq remote model")
		#	except Exception as ex:
		#		print(f"Remote model failed: {ex}")
		#		raise Exception("No working model configuration found")

		# NUOVO CODICE FUNZIONANTE:
		# Configurazione con fallback per modelli locali
		model = None

		# Try 1: Modello locale semplificato
		try:
			print("🔄 Tentativo 1: Modello locale GPT-2")
			model = SimpleLocalModel("microsoft/Phi-4-mini-reasoning")
			print("✅ Usando modello locale GPT-2")
		except Exception as e:
			print(f"❌ Modello locale fallito: {e}")

			# Try 2: Modello remoto (se disponibile)
			try:
				print("🔄 Tentativo 2: Modello remoto Groq")
				model = LiteLLM(model="groq/mixtral-8x7b-32768")
				print("✅ Usando modello remoto Groq")
			except Exception as ex:
				print(f"❌ Modello remoto fallito: {ex}")
				
				# Try 3: Fallback finale - risposta fissa
				class FallbackModel:
					def __call__(self, messages, **kwargs):
						return "Sono un agente semplificato. Il modello AI non è disponibile al momento."
				
				model = FallbackModel()
				print("⚠️ Usando modello di fallback")
		
		# Inizializza l'agente
		self.agent = CodeAgent(
			model=model,
			tools=[
				WebSearchTool(),
				PythonInterpreterTool(),
				WikipediaSearchTool(),
				VisitWebpageTool()
			]
		)
		print("FirstAgent inizializzato.")
	
	def __call__(self, question: str) -> str:
		print(f"Agent ricevuto domanda (primi 50 char): {question[:50]}...")
		try:
			answer = self.agent.run(question)
			print(f"Agent restituisce risposta: {str(answer)[:100]}...")
			return str(answer)
		except Exception as e:
			print(f"Errore nell'agente: {e}")
			return f"Errore nell'agente: {str(e)}"

# --- Basic Agent Definition ---
# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
class BasicAgent:
	### Basic Agent is a placeholder for a simple agent that always returns a fixed answer. ###
	### It is used to demonstrate the structure of an agent. ###
	def __init__(self):
		print("BasicAgent initialized.")
	def __call__(self, question: str) -> str:
		print(f"Agent received question (first 50 chars): {question[:50]}...")
		fixed_answer = "This is a default answer."
		print(f"Agent returning fixed answer: {fixed_answer}")
		return fixed_answer

def run_and_submit_all( profile: gr.OAuthProfile | None):
	"""
	Fetches all questions, runs the BasicAgent on them, submits all answers,
	and displays the results.
	"""
	# --- Determine HF Space Runtime URL and Repo URL ---
	space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code

	if profile:
		username= f"{profile.username}"
		print(f"User logged in: {username}")
	else:
		print("User not logged in.")
		return "Please Login to Hugging Face with the button.", None

	api_url = DEFAULT_API_URL
	questions_url = f"{api_url}/questions"
	submit_url = f"{api_url}/submit"

	# 1. Instantiate Agent ( modify this part to create your agent)
	try:
		agent = FirstAgent()
	except Exception as e:
		print(f"Error instantiating agent: {e}")
		return f"Error initializing agent: {e}", None
	# In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
	agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
	print(agent_code)

	# 2. Fetch Questions
	print(f"Fetching questions from: {questions_url}")
	try:
		response = requests.get(questions_url, timeout=15)
		response.raise_for_status()
		questions_data = response.json()
		if not questions_data:
			print("Fetched questions list is empty.")
			return "Fetched questions list is empty or invalid format.", None
		print(f"Fetched {len(questions_data)} questions.")
	except requests.exceptions.RequestException as e:
		print(f"Error fetching questions from API: {e}")
		print("Attempting to load questions from local file 'questions.json'...")
		try:
			with open("questions.json", "r", encoding="utf-8") as f:
				questions_data = json.load(f)
			if not questions_data:
				return "Both API and local questions file are empty.", None
			print(f"Successfully loaded {len(questions_data)} questions from local file.")
		except FileNotFoundError:
			return "Error: Could not fetch questions from API and 'questions.json' file not found.", None
		except json.JSONDecodeError as json_e:
			return f"Error: Could not fetch questions from API and local file has invalid JSON: {json_e}", None
		except Exception as file_e:
			return f"Error: Could not fetch questions from API and failed to read local file: {file_e}", None
	except requests.exceptions.JSONDecodeError as e:
		print(f"Error decoding JSON response from questions endpoint: {e}")
		print(f"Response text: {response.text[:500]}")
		print("Attempting to load questions from local file 'questions.json'...")
		try:
			with open("questions.json", "r", encoding="utf-8") as f:
				questions_data = json.load(f)
			if not questions_data:
				return "Both API response is invalid and local questions file is empty.", None
			print(f"Successfully loaded {len(questions_data)} questions from local file.")
		except FileNotFoundError:
			return "Error: Could not decode API response and 'questions.json' file not found.", None
		except json.JSONDecodeError as json_e:
			return f"Error: Could not decode API response and local file has invalid JSON: {json_e}", None
		except Exception as file_e:
			return f"Error: Could not decode API response and failed to read local file: {file_e}", None
	except Exception as e:
		print(f"An unexpected error occurred fetching questions: {e}")
		print("Attempting to load questions from local file 'questions.json'...")
		try:
			with open("questions.json", "r", encoding="utf-8") as f:
				questions_data = json.load(f)
			if not questions_data:
				return "Unexpected API error occurred and local questions file is empty.", None
			print(f"Successfully loaded {len(questions_data)} questions from local file.")
		except FileNotFoundError:
			return "Error: Unexpected API error occurred and 'questions.json' file not found.", None
		except json.JSONDecodeError as json_e:
			return f"Error: Unexpected API error occurred and local file has invalid JSON: {json_e}", None
		except Exception as file_e:
			return f"Error: Unexpected API error occurred and failed to read local file: {file_e}", None

	# 3. Run your Agent
	results_log = []
	answers_payload = []
	print(f"Running agent on {len(questions_data)} questions...")
	for item in questions_data:
		task_id = item.get("task_id")
		question_text = item.get("question")
		if not task_id or question_text is None:
			print(f"Skipping item with missing task_id or question: {item}")
			continue
		try:
			submitted_answer = agent(question_text)
			answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
			results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
		except Exception as e:
			print(f"Error running agent on task {task_id}: {e}")
			results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})

	if not answers_payload:
		print("Agent did not produce any answers to submit.")
		return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)

	# 4. Prepare Submission 
	submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
	status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
	print(status_update)

	# 5. Submit
	print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
	try:
		response = requests.post(submit_url, json=submission_data, timeout=60)
		response.raise_for_status()
		result_data = response.json()
		final_status = (
			f"Submission Successful!\n"
			f"User: {result_data.get('username')}\n"
			f"Overall Score: {result_data.get('score', 'N/A')}% "
			f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
			f"Message: {result_data.get('message', 'No message received.')}"
		)
		print("Submission successful.")
		results_df = pd.DataFrame(results_log)
		return final_status, results_df
	except requests.exceptions.HTTPError as e:
		error_detail = f"Server responded with status {e.response.status_code}."
		try:
			error_json = e.response.json()
			error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
		except requests.exceptions.JSONDecodeError:
			error_detail += f" Response: {e.response.text[:500]}"
		status_message = f"Submission Failed: {error_detail}"
		print(status_message)
		results_df = pd.DataFrame(results_log)
		return status_message, results_df
	except requests.exceptions.Timeout:
		status_message = "Submission Failed: The request timed out."
		print(status_message)
		results_df = pd.DataFrame(results_log)
		return status_message, results_df
	except requests.exceptions.RequestException as e:
		status_message = f"Submission Failed: Network error - {e}"
		print(status_message)
		results_df = pd.DataFrame(results_log)
		return status_message, results_df
	except Exception as e:
		status_message = f"An unexpected error occurred during submission: {e}"
		print(status_message)
		results_df = pd.DataFrame(results_log)
		return status_message, results_df


# --- Build Gradio Interface using Blocks ---
with gr.Blocks() as demo:
	gr.Markdown("# Basic Agent Evaluation Runner")
	gr.Markdown(
		"""
		**Instructions:**

		1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
		2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
		3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.

		---
		**Disclaimers:**
		Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
		This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
		"""
	)

	gr.LoginButton()

	run_button = gr.Button("Run Evaluation & Submit All Answers")

	status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
	# Removed max_rows=10 from DataFrame constructor
	results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)

	run_button.click(
		fn=run_and_submit_all,
		outputs=[status_output, results_table]
	)

if __name__ == "__main__":
	print("\n" + "-"*30 + " App Starting " + "-"*30)
	# Check for SPACE_HOST and SPACE_ID at startup for information
	space_host_startup = os.getenv("SPACE_HOST")
	space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup

	if space_host_startup:
		print(f"✅ SPACE_HOST found: {space_host_startup}")
		print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
	else:
		print("ℹ️  SPACE_HOST environment variable not found (running locally?).")

	if space_id_startup: # Print repo URLs if SPACE_ID is found
		print(f"✅ SPACE_ID found: {space_id_startup}")
		print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
		print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
	else:
		print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")

	print("-"*(60 + len(" App Starting ")) + "\n")

	print("Launching Gradio Interface for Basic Agent Evaluation...")
	demo.launch(debug=True, share=False)