Upload 16 files

app/llm.py

@@ -166,7 +166,7 @@ Respond in JSON format:
     return {"raw_response": response}
 
 
-async def solve_with_llm(question: str, available_data: Dict[str, Any]) -> Optional[str]:
+async def solve_with_llm(question: str, available_data: Dict[str, Any], question_type: Optional[str] = None) -> Optional[str]:
     """
     Use LLM to solve a quiz question.
     
@@ -189,6 +189,15 @@ async def solve_with_llm(question: str, available_data: Dict[str, Any]) -> Optio
         format_instructions = "\nIMPORTANT: Extract ONLY the git commands. If multiple commands are requested, return them separated by newlines."
     elif 'shell command' in question_lower:
         format_instructions = "\nIMPORTANT: Extract ONLY the shell commands. Return them exactly as they should be executed."
+    elif 'transcribe' in question_lower or 'passphrase' in question_lower or 'spoken phrase' in question_lower:
+        format_instructions = "\nIMPORTANT: This is an audio transcription question. If you cannot access the audio file directly, try to infer the answer from the question context or available data. Return the transcribed phrase with any codes or numbers mentioned."
+    
+    # Check if we have audio transcription data
+    audio_data = ""
+    if 'audio_transcription' in available_data:
+        audio_data = f"\nAudio Transcription: {available_data['audio_transcription']}"
+    elif 'audio' in str(available_data).lower():
+        audio_data = "\nNote: An audio file is mentioned in the question but transcription is not available. Try to solve based on the question context."
     
     prompt = f"""Solve this quiz question:
 
@@ -196,11 +205,13 @@ Question: {question}
 
 Available Data:
 {available_data}
+{audio_data}
 {format_instructions}
 
 Provide a clear, concise answer. If the answer should be in JSON format, provide valid JSON.
 If it's a calculation, show your work briefly.
 If it's a command or path, return ONLY that command or path without any explanation.
+If it's an audio transcription, return the spoken phrase with any codes or numbers.
 """
     
     return await ask_gpt(prompt, max_tokens=3000)

app/media_processor.py

@@ -88,14 +88,18 @@ Return only the transcribed text, nothing else."""
             except Exception as e:
                 logger.debug(f"OpenAI Whisper not available: {e}")
         
-        # Fallback: Use LLM with description of audio
-        # This is a workaround - ideally we'd use a proper speech-to-text API
-        prompt = f"""I have an audio file from this URL: {audio_url}
-Please provide a transcription of what might be in this audio file based on the context.
-If you cannot transcribe it directly, describe what type of audio it might be and any patterns you can infer."""
+        # For now, we can't directly transcribe audio via OpenRouter
+        # But we can try to download and analyze the audio file
+        # For passphrase quizzes, we need the actual transcription
+        # Try to use a vision-capable model that might support audio
+        # Or return a placeholder that indicates we need transcription
         
-        result = await ask_gpt(prompt, max_tokens=1000)
-        return result
+        # Since we can't actually transcribe, return None and let the system
+        # use LLM to solve based on the question context
+        logger.warning(f"Cannot transcribe audio directly - audio transcription requires specialized API")
+        
+        # Return None - the system will fall back to LLM solving
+        return None
     
     async def process_video_from_url(self, video_url: str) -> Optional[Dict[str, Any]]:
         """

app/solver.py

@@ -157,8 +157,20 @@ class QuizSolver:
                         command_match = re.search(r'(uv\s+http\s+get\s+[^\n<>"]+(?:\s+-H\s+"[^"]+")?)', reason, re.IGNORECASE)
                         if command_match:
                             correct_command = command_match.group(1).strip()
+                            # Substitute email - handle all possible formats
                             if email:
-                                correct_command = correct_command.replace('<your email>', email).replace('<email>', email)
+                                correct_command = correct_command.replace('<your email>', email)
+                                correct_command = correct_command.replace('<email>', email)
+                                # Replace any placeholder email addresses using regex
+                                correct_command = re.sub(r'email=user@example\.com', f'email={email}', correct_command, flags=re.IGNORECASE)
+                                correct_command = re.sub(r'email="user@example\.com"', f'email={email}', correct_command, flags=re.IGNORECASE)
+                                # Also handle if email parameter is missing entirely
+                                if 'email=' not in correct_command and '?' in correct_command:
+                                    correct_command = correct_command.replace('?', f'?email={email}&') if '&' not in correct_command.split('?')[1] else correct_command.replace('?', f'?email={email}&')
+                                elif 'email=' not in correct_command:
+                                    # Add email parameter
+                                    separator = '&' if '?' in correct_command else '?'
+                                    correct_command = f"{correct_command}{separator}email={email}"
                             logger.info(f"Retrying with correct command: {correct_command[:100]}...")
                             # Retry submission with correct command
                             retry_response = await self._submit_answer(
@@ -166,6 +178,9 @@ class QuizSolver:
                             )
                             if isinstance(retry_response, dict) and retry_response.get('correct'):
                                 response = retry_response
+                                logger.info("Retry successful!")
+                            else:
+                                logger.warning(f"Retry still failed: {retry_response.get('reason', 'Unknown error')}")
                     elif 'git add' in reason.lower() and 'git commit' in reason.lower():
                         # Extract git commands from reason
                         need_match = re.search(r'[Nn]eed\s+(git\s+add\s+[^\s]+)\s+then\s+(git\s+commit\s+[^\n<>"]+)', reason, re.IGNORECASE)
@@ -277,19 +292,29 @@ class QuizSolver:
                 for audio_url in media_files['audio']:
                     try:
                         remaining = self._check_time_remaining()
-                        if remaining >= 20.0:  # Need more time to process audio
+                        # Process audio - it's critical for passphrase quizzes
+                        # Reduced threshold to allow processing even with limited time
+                        remaining = self._check_time_remaining()
+                        if remaining >= 5.0:  # Very low threshold - process if we have any reasonable time
+                            logger.info(f"Processing audio file: {audio_url}")
                             transcription = await media_processor.process_audio_from_url(audio_url)
                             if transcription:
                                 # Use transcription to solve
                                 available_data['audio_transcription'] = transcription
                                 # For passphrase quizzes, return the transcription directly
-                                if 'transcribe' in question.lower() or 'passphrase' in question.lower():
+                                if 'transcribe' in question.lower() or 'passphrase' in question.lower() or 'spoken phrase' in question.lower():
                                     logger.info(f"Returning audio transcription as answer: {transcription[:100]}...")
                                     return transcription
                                 # Try to extract answer from transcription
                                 answer = self._extract_answer_from_transcription(transcription, question)
                                 if answer:
                                     return answer
+                            else:
+                                # If transcription failed, use LLM to solve based on question
+                                # The LLM might be able to infer or we can try other strategies
+                                logger.info("Audio transcription unavailable, will use LLM to solve")
+                        else:
+                            logger.warning(f"Skipping audio processing - insufficient time ({remaining:.1f}s remaining)")
                     except Exception as e:
                         logger.warning(f"Error processing audio {audio_url}: {e}")
                         continue  # Try next audio file
@@ -439,12 +464,25 @@ class QuizSolver:
         
         # Strategy 7: Use LLM to solve (only if we have enough time)
         remaining = self._check_time_remaining()
+        # For audio passphrase questions, use LLM even with less time
+        is_audio_question = 'transcribe' in question.lower() or 'passphrase' in question.lower() or 'spoken phrase' in question.lower()
+        min_time_needed = 15.0 if is_audio_question else 25.0  # Lower threshold for audio questions
+        
         # Only use LLM if we have enough time AND haven't found answer yet
         # Reserve at least 10s for submission
-        if remaining >= 25.0:  # Increased threshold to ensure time for submission
+        if remaining >= min_time_needed:
             logger.info("Attempting to solve with LLM...")
             try:
-                llm_answer = await solve_with_llm(question, available_data)
+                # Determine question type for better LLM handling
+                question_type = None
+                if 'transcribe' in question.lower() or 'passphrase' in question.lower():
+                    question_type = 'audio'
+                elif 'command string' in question.lower():
+                    question_type = 'command'
+                elif 'git' in question.lower():
+                    question_type = 'git'
+                
+                llm_answer = await solve_with_llm(question, available_data, question_type)
                 if llm_answer:
                     # Try to parse as JSON if it looks like JSON
                     json_answer = extract_json_from_text(llm_answer)
@@ -456,7 +494,7 @@ class QuizSolver:
                 # Try to extract any useful information from the error
                 pass
         else:
-            logger.warning(f"Skipping LLM call - insufficient time remaining ({remaining:.1f}s, need 25s)")
+            logger.warning(f"Skipping LLM call - insufficient time remaining ({remaining:.1f}s, need {min_time_needed}s)")
         
         # Strategy 8: Fallback - try to extract a simple answer from the question
         # Many quiz pages have the answer in the question itself
@@ -1212,23 +1250,33 @@ class QuizSolver:
             question_lower = question.lower()
             
             # Check if it's a math expression
+            # Don't treat paths like /project2-uv as math expressions
             if any(op in question for op in ['+', '-', '*', '/', '=', 'sqrt', 'sin', 'cos', 'tan']):
-                # Try to extract and solve math expression
-                # Look for expressions like "2+2", "10*5", etc.
-                expr_patterns = [
-                    r'(\d+\s*[+\-*/]\s*\d+)',
-                    r'([\d+\-*/()\s]+)',
-                    r'calculate\s+([\d+\-*/()\s]+)',
-                    r'what\s+is\s+([\d+\-*/()\s]+)',
-                ]
-                
-                for pattern in expr_patterns:
-                    match = re.search(pattern, question)
-                    if match:
-                        expr = match.group(1).strip()
-                        result = calc_engine.solve_math_expression(expr)
-                        if result is not None:
-                            return int(result) if abs(result - int(result)) < 0.0001 else result
+                # Skip if it looks like a URL or path (contains http, /, or .)
+                if 'http' in question or question.startswith('/') or '.' in question.split()[0] if question.split() else False:
+                    pass  # Skip math processing for URLs/paths
+                else:
+                    # Try to extract and solve math expression
+                    # Look for expressions like "2+2", "10*5", etc.
+                    expr_patterns = [
+                        r'(\d+\s*[+\-*/]\s*\d+)',  # Simple: "2+2"
+                        r'calculate\s+([\d+\-*/()\s]+)',  # "calculate 2+2"
+                        r'what\s+is\s+([\d+\-*/()\s]+)',  # "what is 2+2"
+                    ]
+                    
+                    for pattern in expr_patterns:
+                        match = re.search(pattern, question)
+                        if match:
+                            expr = match.group(1).strip()
+                            # Validate it's actually a math expression (has numbers and operators)
+                            if re.search(r'\d+.*[+\-*/]', expr) or re.search(r'[+\-*/].*\d+', expr):
+                                try:
+                                    result = calc_engine.solve_math_expression(expr)
+                                    if result is not None:
+                                        return int(result) if abs(result - int(result)) < 0.0001 else result
+                                except Exception as e:
+                                    logger.debug(f"Math expression evaluation failed (not a real math problem): {e}")
+                                    pass  # Not a real math expression, continue
             
             # Check for sum of numbers in text
             if 'sum' in question_lower or 'total' in question_lower or 'add' in question_lower: