Fix 7 medium-priority issues: resume, timeout, logging, prompts, dead code

- Add --resume flag to continue interrupted benchmark runs
- Uncomment request_timeout (200s) for thinking models
- Use print() for colored status output to avoid ANSI codes in log files
- Tailor reprompt examples to question type (no longer shows all formats)
- Fix api_success flag: now correctly False when API returns empty content
- Remove dead code: calculate_accuracy (unused in production)
- Fix misleading summary.md calculation: show category breakdown instead of
fake arithmetic formula that didn't account for partial marks
- Update README.md: document --resume, fix output file descriptions,
update scoring notes, add resume and rate-limit retry documentation

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

README.md

@@ -223,27 +223,36 @@ This repository contains scripts to run the benchmark evaluation directly:
     python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "google/gemini-2.5-pro-preview-03-25" --question_ids "N24T3001,N24T3002,JA24P1M01"
     ```
 
+    **Resume an interrupted run:**
+    ```bash
+    # Resume from an existing results directory (skips already-completed questions)
+    python src/benchmark_runner.py --model "google/gemini-2.5-pro-preview-03-25" --resume results/google_gemini-2.5-pro-preview-03-25_NEET_2024_20250524_141230
+    ```
+
     **Custom output directory:**
     ```bash
     python src/benchmark_runner.py --config configs/benchmark_config.yaml --model "openai/gpt-4o" --output_dir my_custom_results
     ```
 
-    **Available filtering options:**
+    **Available options:**
     - `--exam_name`: Choose from `NEET`, `JEE_MAIN`, `JEE_ADVANCED`, or `all` (default)
     - `--exam_year`: Choose from available years (`2024`, `2025`, etc.) or `all` (default)
     - `--question_ids`: Comma-separated list of specific question IDs to evaluate (e.g., "N24T3001,JA24P1M01")
+    - `--resume`: Path to an existing results directory to resume an interrupted run
 
 6.  **Check Results:**
     *   Results for each model run will be saved in timestamped subdirectories within the `results/` folder.
     *   Each run's folder (e.g., `results/google_gemini-2.5-pro-preview-03-25_NEET_2024_20250524_141230/`) contains:
-        *   **`predictions.jsonl`**: Detailed results for each question including:
-            - Model predictions and ground truth
+        *   **`predictions.jsonl`**: Raw API responses for each question including:
             - Raw LLM responses
-            - Evaluation status and marks awarded
             - API call success/failure information
-        *   **`summary.json`**: Overall scores and statistics in JSON format
+            - Parse success status and errors
+        *   **`summary.jsonl`**: Per-question scored results including:
+            - Predicted answers and ground truth
+            - Evaluation status and marks awarded
         *   **`summary.md`**: Human-readable Markdown summary with:
             - Overall exam scores
+            - Question type breakdown
             - Section-wise breakdown (by subject)
             - Detailed statistics on correct/incorrect/skipped questions
 
@@ -252,39 +261,47 @@ This repository contains scripts to run the benchmark evaluation directly:
 The benchmark implements authentic scoring systems for each exam type:
 
 ### NEET Scoring
-- **Single Correct MCQ**: +4 for correct, -1 for incorrect, 0 for skipped
+- **Single Correct MCQ**: +4 for correct, -1 for incorrect, 0 for skipped/API failure
 
-### JEE Main Scoring  
-- **Single Correct MCQ**: +4 for correct, -1 for incorrect, 0 for skipped
-- **Integer Type**: +4 for correct, 0 for incorrect, 0 for skipped
+### JEE Main Scoring
+- **Single Correct MCQ**: +4 for correct, -1 for incorrect, 0 for skipped/API failure
+- **Integer Type**: +4 for correct, 0 for incorrect, 0 for skipped/API failure
 
 ### JEE Advanced Scoring
-- **Single Correct MCQ**: +3 for correct, -1 for incorrect, 0 for skipped
-- **Multiple Correct MCQ**: Complex partial marking system:
+- **Single Correct MCQ**: +3 for correct, -1 for incorrect, 0 for skipped/API failure
+- **Multiple Correct MCQ**: Partial marking system:
   - +4 for all correct options selected
   - +3 for 3 out of 4 correct options (when 4 are correct)
   - +2 for 2 out of 3+ correct options
   - +1 for 1 out of 2+ correct options
   - -2 for any incorrect option selected
-  - 0 for skipped
-- **Integer Type**: +4 for correct, 0 for incorrect, 0 for skipped
+  - 0 for skipped/API failure
+- **Integer Type**: +4 for correct, 0 for incorrect, 0 for skipped/API failure
+
+> **Note:** API failures and parse failures are scored as 0 (no penalty) since they do not represent a deliberate wrong choice.
 
 ## Advanced Features
 
 ### Retry Mechanism
 - Automatic retry for failed API calls (up to 3 attempts with exponential backoff)
+- Retries on HTTP 429 (rate limit), 500, 502, 503, 504 status codes
 - Separate retry pass for questions that failed initially
 - Comprehensive error tracking and reporting
 
+### Resume Capability
+- Resume interrupted benchmark runs with `--resume <results_dir>`
+- Reads existing `summary.jsonl` to identify completed questions and skips them
+- Appends new results to the same output files
+
 ### Re-prompting System
 - If initial response parsing fails, the system automatically re-prompts the model
 - Uses the previous response to ask for properly formatted answers
-- Adapts prompts based on question type (MCQ vs Integer)
+- Shows only relevant format examples based on question type (MCQ single, MCQ multiple, or integer)
 
 ### Comprehensive Evaluation
 - Tracks multiple metrics: correct answers, partial credit, skipped questions, API failures
 - Section-wise breakdown by subject
-- Detailed logging with color-coded progress indicators
+- Color-coded progress indicators in terminal output
 
 ## Dataset Structure
 

configs/benchmark_config.yaml

@@ -8,6 +8,7 @@ openrouter_models:
   - "openai/o3"
   - "openai/gpt-5"
   - "x-ai/grok-4-fast:free"
+  - "google/gemini-3-pro-preview"
   # - "google/gemini-pro-vision" # Example - uncomment or add others
   # - "anthropic/claude-3-opus" # Example - check vision support and access
   # - "anthropic/claude-3-sonnet"
@@ -24,4 +25,5 @@ results_base_dir: "results"
 # Maximum tokens to generate in the response. Keep it low as we expect only numbers.
 max_tokens: 10000
 # Timeout for each API request in seconds.
-#request_timeout: 200
+# Set high enough for thinking models (o3, Gemini Flash Thinking) which can take longer.
+request_timeout: 200

src/benchmark_runner.py

@@ -21,7 +21,7 @@ MAGENTA = '\033[95m' # For API failures
 from utils import load_api_key
 from llm_interface import get_openrouter_prediction
 # Import evaluation functions
-from evaluation import calculate_accuracy, calculate_exam_scores, calculate_single_question_score_details
+from evaluation import calculate_exam_scores, calculate_single_question_score_details
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -184,8 +184,7 @@ def generate_markdown_summary(summary: Dict[str, Any], filepath: str):
                 for q_type in sorted_q_types:
                     stats = question_type_breakdown[q_type]
                     q_type_display = q_type.replace('_', ' ').title()
-                    max_score_per_q = stats.get('max_score_per_question', 0)
-                    
+
                     correct_count_q = stats.get('correct_full', 0)
                     partial_count_q = stats.get('partial_correct', 0)
                     incorrect_count_q = stats.get('incorrect_choice', 0)
@@ -193,31 +192,22 @@ def generate_markdown_summary(summary: Dict[str, Any], filepath: str):
                     api_fail_count_q = stats.get('api_parse_failures', 0)
                     score_q = stats.get('score', 0)
 
-                    calculation_parts = []
+                    breakdown_parts = []
                     if correct_count_q > 0:
-                        calculation_parts.append(f"{correct_count_q} Correct (+{max_score_per_q})")
+                        breakdown_parts.append(f"{correct_count_q} Correct")
                     if partial_count_q > 0:
-                        # For partial, we can't easily show the exact score per question without more detail
-                        # For now, just indicate partials.
-                        calculation_parts.append(f"{partial_count_q} Partial")
+                        breakdown_parts.append(f"{partial_count_q} Partial")
                     if incorrect_count_q > 0:
-                        # Need to know penalty for incorrect. Assuming -1 for MCQ_SINGLE_CORRECT, -2 for MCQ_MULTIPLE_CORRECT
-                        # For INTEGER, penalty is 0. This needs to be more robust if penalties vary.
-                        penalty_per_incorrect = 0
-                        if q_type == "MCQ_SINGLE_CORRECT": penalty_per_incorrect = -1
-                        elif q_type == "MCQ_MULTIPLE_CORRECT": penalty_per_incorrect = -2
-                        calculation_parts.append(f"{incorrect_count_q} Incorrect ({penalty_per_incorrect})")
+                        breakdown_parts.append(f"{incorrect_count_q} Incorrect")
                     if skipped_count_q > 0:
-                        calculation_parts.append(f"{skipped_count_q} Skipped (0)")
+                        breakdown_parts.append(f"{skipped_count_q} Skipped")
                     if api_fail_count_q > 0:
-                        calculation_parts.append(f"{api_fail_count_q} API/Parse Fail (0)")
-                    
-                    calculation_str = " + ".join(part for part in calculation_parts if part)
-                    if not calculation_str:
-                        calculation_str = "No questions of this type processed or all had 0 score change."
+                        breakdown_parts.append(f"{api_fail_count_q} API/Parse Fail")
+
+                    breakdown_str = ", ".join(breakdown_parts) if breakdown_parts else "No questions processed"
 
                     md_content.append(f"**{q_type_display} ({stats.get('count', 0)} questions):** {score_q} marks")
-                    md_content.append(f"  *Calculation:* {calculation_str} = {score_q}")
+                    md_content.append(f"  *Breakdown:* {breakdown_str}")
             else:
                 md_content.append("No question type breakdown available.")
 
@@ -313,7 +303,7 @@ def process_question(
         request_timeout=config.get("request_timeout", 60),
     )
 
-    api_success = True
+    api_success = raw_response is not None  # False if API returned empty content
     parse_success = parsed_answer is not None
 
     # --- Re-prompt Logic ---
@@ -352,8 +342,8 @@ def process_question(
             })
     else:
         current_error = result_data.get("error")
-        if api_success and raw_response is None and parsed_answer is None:
-            current_error = "API call returned empty content. Re-prompt skipped."
+        if not api_success:
+            current_error = "API call returned empty content."
 
         if isinstance(parsed_answer, list):
             parsed_answer = [str(item) for item in parsed_answer]
@@ -398,15 +388,15 @@ def log_question_result(result_data: Dict[str, Any], prefix: str = "") -> str:
     log_message_suffix = f"(Attempt {result_data['attempt']})"
 
     if not result_data["api_call_successful"]:
-        logging.info(f"{MAGENTA}{log_message_prefix} API Call Failed {log_message_suffix}{RESET}")
+        print(f"{MAGENTA}{log_message_prefix} API Call Failed {log_message_suffix}{RESET}")
         return "api_fail"
 
     if not result_data["parse_successful"]:
-        logging.info(f"{CYAN}{log_message_prefix} Failed to parse answer {log_message_suffix}{RESET}")
+        print(f"{CYAN}{log_message_prefix} Failed to parse answer {log_message_suffix}{RESET}")
         return "parse_fail"
 
     if result_data["predicted_answer"] == "SKIP":
-        logging.info(f"{YELLOW}{log_message_prefix} Skipped {log_message_suffix}{RESET}")
+        print(f"{YELLOW}{log_message_prefix} Skipped {log_message_suffix}{RESET}")
         return "skipped"
 
     marks_awarded = result_data.get("marks_awarded", 0)
@@ -435,24 +425,45 @@ def log_question_result(result_data: Dict[str, Any], prefix: str = "") -> str:
     known_eval_skip_statuses = ["SKIPPED_BY_EVAL", "SKIPPED"]
 
     if is_considered_correct:
-        logging.info(f"{GREEN}{log_message_prefix} Correct (log) - Marks: {marks_awarded}, Status: {log_display_status} {log_message_suffix}{RESET}")
+        print(f"{GREEN}{log_message_prefix} Correct - Marks: {marks_awarded}, Status: {log_display_status} {log_message_suffix}{RESET}")
         return "correct"
     elif status_check_string in known_eval_skip_statuses:
-        logging.info(f"{YELLOW}{log_message_prefix} Skipped by Eval - Marks: {marks_awarded}, Status: {log_display_status} {log_message_suffix}{RESET}")
+        print(f"{YELLOW}{log_message_prefix} Skipped by Eval - Marks: {marks_awarded}, Status: {log_display_status} {log_message_suffix}{RESET}")
         return "skipped"
     else:
-        logging.info(f"{RED}{log_message_prefix} Incorrect (log) - Marks: {marks_awarded}, Status: {log_display_status} {log_message_suffix}{RESET}")
+        print(f"{RED}{log_message_prefix} Incorrect - Marks: {marks_awarded}, Status: {log_display_status} {log_message_suffix}{RESET}")
         return "incorrect"
 
 
+def load_completed_question_ids(summary_details_path: str) -> set:
+    """Reads summary.jsonl and returns a set of question_ids that have already been processed."""
+    completed_ids = set()
+    if not os.path.exists(summary_details_path):
+        return completed_ids
+    try:
+        with open(summary_details_path, 'r') as f:
+            for line in f:
+                try:
+                    data = json.loads(line)
+                    qid = data.get("question_id")
+                    if qid:
+                        completed_ids.add(qid)
+                except json.JSONDecodeError:
+                    continue
+    except IOError as e:
+        logging.warning(f"Could not read {summary_details_path} for resume: {e}")
+    return completed_ids
+
+
 def run_benchmark(
-    config: dict, 
-    api_key: str, 
-    model_to_run: str, # Changed from models_override
-    output_dir_override: str | None = None, 
-    exam_name_choice: str | None = None, # Changed from exam_name_filter
-    exam_year_choice: str | None = None,   # Changed from exam_year_filter
-    question_ids_str: str | None = None # New argument
+    config: dict,
+    api_key: str,
+    model_to_run: str,
+    output_dir_override: str | None = None,
+    exam_name_choice: str | None = None,
+    exam_year_choice: str | None = None,
+    question_ids_str: str | None = None,
+    resume_dir: str | None = None
 ):
     """Runs the benchmark evaluation loop with incremental saving and retries."""
 
@@ -521,34 +532,50 @@ def run_benchmark(
 
      # --- Main Loop: Iterate through models ---
     for model_id in models_to_run:
-        # total_questions here should refer to the length of the potentially filtered dataset
-        current_total_questions = len(dataset) 
-        logging.info(f"--- Starting benchmark for model: {model_id} (Processing {current_total_questions} questions) ---")
-
-        # Create timestamped output directory for this model run
-        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-        safe_model_name = model_id.replace('/', '_') # model_id is already the single model_to_run
-        dir_name_parts = [safe_model_name]
-        
-        # Append exam name and year to directory if they are specific (not "all")
-        current_exam_name_for_dir = exam_name_choice if exam_name_choice and exam_name_choice.lower() != "all" else "AllExams"
-        current_exam_year_for_dir = exam_year_choice if exam_year_choice and exam_year_choice.lower() != "all" else "AllYears"
-
-        if current_exam_name_for_dir != "AllExams":
-            dir_name_parts.append(current_exam_name_for_dir.replace('/', '_'))
-        if current_exam_year_for_dir != "AllYears":
-             dir_name_parts.append(str(current_exam_year_for_dir)) # Already string or 'all'
-        
-        dir_name_parts.append(timestamp)
-        
-        model_output_dir_name = "_".join(filter(None, dir_name_parts)) # Filter out None if any part was None
-        model_output_dir = os.path.join(base_output_dir, model_output_dir_name)
+        logging.info(f"--- Starting benchmark for model: {model_id} ---")
+
+        # Set up output directory (resume existing or create new)
+        if resume_dir:
+            model_output_dir = resume_dir
+            timestamp = os.path.basename(resume_dir).rsplit('_', 2)[-2] + '_' + os.path.basename(resume_dir).rsplit('_', 1)[-1] if '_' in os.path.basename(resume_dir) else datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        else:
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            safe_model_name = model_id.replace('/', '_')
+            dir_name_parts = [safe_model_name]
+
+            current_exam_name_for_dir = exam_name_choice if exam_name_choice and exam_name_choice.lower() != "all" else "AllExams"
+            current_exam_year_for_dir = exam_year_choice if exam_year_choice and exam_year_choice.lower() != "all" else "AllYears"
+
+            if current_exam_name_for_dir != "AllExams":
+                dir_name_parts.append(current_exam_name_for_dir.replace('/', '_'))
+            if current_exam_year_for_dir != "AllYears":
+                dir_name_parts.append(str(current_exam_year_for_dir))
+
+            dir_name_parts.append(timestamp)
+
+            model_output_dir_name = "_".join(filter(None, dir_name_parts))
+            model_output_dir = os.path.join(base_output_dir, model_output_dir_name)
+
         os.makedirs(model_output_dir, exist_ok=True)
         predictions_path = os.path.join(model_output_dir, "predictions.jsonl")
-        summary_details_path = os.path.join(model_output_dir, "summary.jsonl") # New file for per-question summary details
-        markdown_summary_path = os.path.join(model_output_dir, "summary.md") # Define path for MD summary
+        summary_details_path = os.path.join(model_output_dir, "summary.jsonl")
+        markdown_summary_path = os.path.join(model_output_dir, "summary.md")
         logging.info(f"Results for {model_id} will be saved to: {model_output_dir}")
 
+        # Resume: skip already-completed questions
+        if resume_dir:
+            completed_ids = load_completed_question_ids(summary_details_path)
+            if completed_ids:
+                logging.info(f"Resuming: found {len(completed_ids)} already-completed questions. Skipping them.")
+                dataset = dataset.filter(lambda example: example.get('question_id') not in completed_ids)
+                logging.info(f"Remaining questions to process: {len(dataset)}")
+                if len(dataset) == 0:
+                    logging.info("All questions already completed. Nothing to resume.")
+                    return
+
+        current_total_questions = len(dataset)
+        logging.info(f"Processing {current_total_questions} questions for model: {model_id}")
+
         model_results = [] # Stores results in memory for final calculation
         failed_questions_data = [] # Stores data needed to retry failed questions
 
@@ -744,6 +771,12 @@ if __name__ == "__main__":
         default=None,
         help="Optional: Comma-separated list of specific question IDs to run (e.g., ID1,ID2,ID3)."
     )
+    parser.add_argument(
+        "--resume",
+        type=str,
+        default=None,
+        help="Optional: Path to an existing results directory to resume an interrupted run."
+    )
     args = parser.parse_args()
 
     # Dynamically update config path if user provides a different one
@@ -774,13 +807,14 @@ if __name__ == "__main__":
 
         # Run the benchmark
         run_benchmark(
-            config=config, 
-            api_key=api_key, 
-            model_to_run=args.model, 
+            config=config,
+            api_key=api_key,
+            model_to_run=args.model,
             output_dir_override=args.output_dir,
             exam_name_choice=args.exam_name,
             exam_year_choice=args.exam_year,
-            question_ids_str=args.question_ids
+            question_ids_str=args.question_ids,
+            resume_dir=args.resume
         )
     except (ValueError, FileNotFoundError, yaml.YAMLError) as e:
         logging.error(f"Setup failed: {e}")

src/evaluation.py

@@ -5,58 +5,6 @@ from typing import List, Optional, Union, Dict, Any
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-def calculate_accuracy(predictions: List[Optional[List[str]]], ground_truths: List[List[str]]) -> float:
-    """
-    Calculates the accuracy of LLM predictions against ground truths.
-
-    Accuracy is defined as the percentage of predictions where the predicted list
-    of answer strings exactly matches the ground truth list of answer strings
-    (order within the list does not matter, comparison is case-insensitive).
-    A prediction of None (due to parsing failure) is considered incorrect.
-
-    Args:
-        predictions (List[Optional[List[str]]]): A list where each element is either a list
-                                                 of predicted answer strings or None if
-                                                 parsing failed for that question.
-        ground_truths (List[List[str]]): A list where each element is a list of
-                                         ground truth answer strings.
-
-    Returns:
-        float: The calculated accuracy (between 0.0 and 1.0).
-
-    Raises:
-        ValueError: If the lengths of predictions and ground_truths lists do not match.
-    """
-    if len(predictions) != len(ground_truths):
-        raise ValueError(f"Length mismatch: Predictions ({len(predictions)}) vs Ground Truths ({len(ground_truths)})")
-
-    if not ground_truths:
-        return 0.0 # Avoid division by zero if the list is empty
-
-    correct_count = 0
-    for i, pred_list_orig in enumerate(predictions):
-        truth_list_orig = ground_truths[i]
-
-        # Convert to uppercase and sort for case-insensitive, order-independent comparison
-        # Handle None case for prediction
-        # Ensure elements are strings before calling upper()
-        sorted_pred = sorted([str(p).upper() for p in pred_list_orig]) if pred_list_orig is not None else None
-        sorted_truth = sorted([str(t).upper() for t in truth_list_orig])
-
-
-        if sorted_pred is not None and sorted_pred == sorted_truth:
-            correct_count += 1
-        else:
-            # Log incorrect only if prediction was not None (parsing succeeded but answer wrong)
-            if sorted_pred is not None:
-                 logging.debug(f"Incorrect prediction for index {i}: Pred={sorted_pred}, Truth={sorted_truth} (Original Pred: {pred_list_orig}, Original Truth: {truth_list_orig})")
-            # If sorted_pred is None, it means parsing failed or API failed, already counted as incorrect implicitly
-
-
-    accuracy = correct_count / len(ground_truths)
-    logging.info(f"Accuracy calculated: {correct_count}/{len(ground_truths)} = {accuracy:.4f}")
-    return accuracy
-
 
 def get_subject_as_section(subject: str, question_num_for_log: int) -> Optional[str]:
     """
@@ -410,27 +358,6 @@ def calculate_exam_scores(results: List[Dict[str, Any]]) -> Dict[str, Any]:
 if __name__ == '__main__':
     print("Running evaluation tests...")
 
-    # --- Test calculate_accuracy (now with strings) ---
-    print("\n--- Testing calculate_accuracy ---")
-    preds1_str = [["1"], ["2"], ["1", "3"]]
-    truths1_str = [["1"], ["2"], ["3", "1"]]
-    acc1_str = calculate_accuracy(preds1_str, truths1_str)
-    print(f"Test Case 1 (Accuracy - String): Preds={preds1_str}, Truths={truths1_str} -> Accuracy: {acc1_str} (Expected: 1.0)")
-    assert acc1_str == 1.0
-
-    preds2_str = [["A"], ["B"], ["A", "C"]]
-    truths2_str = [["a"], ["b"], ["c", "a"]] # Test case-insensitivity
-    acc2_str = calculate_accuracy(preds2_str, truths2_str)
-    print(f"Test Case 2 (Accuracy - String Case-Insensitive): Preds={preds2_str}, Truths={truths2_str} -> Accuracy: {acc2_str} (Expected: 1.0)")
-    assert acc2_str == 1.0
-    
-    preds3_str = [["10"], None, ["5"]]
-    truths3_str = [["10"], ["7"], ["5"]]
-    acc3_str = calculate_accuracy(preds3_str, truths3_str)
-    print(f"Test Case 3 (Accuracy - String with None): Preds={preds3_str}, Truths={truths3_str} -> Accuracy: {acc3_str} (Expected: {2/3})")
-    assert acc3_str == (2/3)
-
-
     # --- Test calculate_exam_scores (now with strings) ---
     print("\n--- Testing calculate_exam_scores ---")
     test_results_exam = [

src/llm_interface.py

@@ -8,11 +8,12 @@ from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_excep
 
 from utils import parse_llm_answer
 from prompts import (
-    INITIAL_PROMPT_TEMPLATE, 
+    INITIAL_PROMPT_TEMPLATE,
     REPROMPT_PROMPT_TEMPLATE,
     get_answer_format_instruction,
     get_example_instruction,
-    get_specific_instructions_reprompt
+    get_specific_instructions_reprompt,
+    get_reprompt_example_instruction
 )
 
 # Configure logging
@@ -52,11 +53,13 @@ def encode_image_to_base64(image: Image.Image) -> str:
 def construct_reprompt_prompt(previous_raw_response: str, question_type: str) -> list:
     """Constructs the message list for a re-prompt API call based on question_type."""
     specific_instructions = get_specific_instructions_reprompt(question_type)
+    reprompt_example_instruction = get_reprompt_example_instruction(question_type)
 
     prompt_text = REPROMPT_PROMPT_TEMPLATE.format(
         previous_raw_response=previous_raw_response,
         question_type=question_type,
-        specific_instructions=specific_instructions
+        specific_instructions=specific_instructions,
+        reprompt_example_instruction=reprompt_example_instruction
     )
     messages = [{"role": "user", "content": prompt_text}]
     return messages

src/prompts.py

@@ -41,6 +41,13 @@ SPECIFIC_INSTRUCTIONS_REPROMPT = {
     "DEFAULT": "provide the answer according to the question format"
 }
 
+REPROMPT_EXAMPLE_INSTRUCTIONS = {
+    "MCQ_SINGLE_CORRECT": "Example for single correct MCQ option 'A': <answer>A</answer>\nExample for single correct MCQ option '2': <answer>2</answer>",
+    "MCQ_MULTIPLE_CORRECT": "Example for multiple correct MCQ options 'A' and 'C': <answer>A,C</answer>\nExample for single correct option 'B': <answer>B</answer>",
+    "INTEGER": "Example for integer answer: <answer>42</answer>\nExample for decimal answer: <answer>12.75</answer>",
+    "DEFAULT": "Example: <answer>Your Answer</answer>",
+}
+
 REPROMPT_PROMPT_TEMPLATE = """You previously provided the following response to an exam question:
 --- PREVIOUS RESPONSE START ---
 {previous_raw_response}
@@ -50,11 +57,7 @@ Your previous response did not correctly format the final answer within <answer>
 
 Please re-examine your previous reasoning and {specific_instructions}, enclosed in <answer> tags.
 
-Example for single correct MCQ option 'A': <answer>A</answer>
-Example for single correct MCQ option '2': <answer>2</answer>
-Example for multiple correct MCQ options 'A' and 'C': <answer>A,C</answer>
-Example for integer answer: <answer>42</answer>
-Example for decimal answer: <answer>12.75</answer>
+{reprompt_example_instruction}
 If you are unsure or cannot determine the answer: <answer>SKIP</answer>
 
 It is crucial that your response contains ONLY the <answer> tag with the correct option identifier(s), numerical value(s) OR the word SKIP inside. Do not include any other text, explanation, or formatting."""
@@ -69,3 +72,6 @@ def get_example_instruction(question_type: str) -> str:
 
 def get_specific_instructions_reprompt(question_type: str) -> str:
     return SPECIFIC_INSTRUCTIONS_REPROMPT.get(question_type, SPECIFIC_INSTRUCTIONS_REPROMPT["DEFAULT"])
+
+def get_reprompt_example_instruction(question_type: str) -> str:
+    return REPROMPT_EXAMPLE_INSTRUCTIONS.get(question_type, REPROMPT_EXAMPLE_INSTRUCTIONS["DEFAULT"])