AI iteration with re-validation + steps log UI; show steps by default; optional iterate-until-valid with max attempts

app.py

@@ -222,25 +222,13 @@ def filter_validation_results_by_class(validation_results: str, rdf_content: str
     return {k: '\n'.join(v) for k, v in class_results.items() if v}
 
 def get_ai_suggestions(validation_results: str, rdf_content: str, include_warnings: bool = False) -> str:
+    """Generate AI-powered, plain-language suggestions based on validation results.
+
+    Avoids RDF/SHACL jargon and focuses on actionable fixes.
     """
-    Generate AI-powered fix suggestions for invalid RDF/XML.
-    
-    This tool analyzes validation results and provides actionable suggestions
-    for fixing RDF/XML validation errors using AI or rule-based analysis.
-    
-    Args:
-        validation_results (str): The validation error messages
-        rdf_content (str): The original RDF/XML content that failed validation
-        include_warnings (bool): Whether to include warnings in suggestions
-    
-    Returns:
-        str: Detailed suggestions for fixing the RDF validation issues
-    """
-    
     if not OPENAI_AVAILABLE:
         return generate_manual_suggestions(validation_results)
-    
-    # Get API key dynamically at runtime
+
     current_api_key = os.getenv('HF_API_KEY', '')
     if not current_api_key:
         return f"""
@@ -248,9 +236,8 @@ def get_ai_suggestions(validation_results: str, rdf_content: str, include_warnin
 
 {generate_manual_suggestions(validation_results)}
 """
-    
+
     try:
-        # Use OpenAI client with your Hugging Face Inference Endpoint
         client = get_openai_client()
         if not client:
             return f"""
@@ -258,26 +245,36 @@ def get_ai_suggestions(validation_results: str, rdf_content: str, include_warnin
 
 {generate_manual_suggestions(validation_results)}
 """
-        
-        severity_instruction = "Focus only on violations (errors) and ignore any warnings." if not include_warnings else "Address both violations and warnings."
-        
-        # Filter validation results by class to reduce token usage
+
+        severity_instruction = (
+            "Focus only on violations (errors) and ignore any warnings."
+            if not include_warnings else
+            "Address both violations and warnings."
+        )
+
+        # Group errors by class to focus the prompt
         class_results = filter_validation_results_by_class(validation_results, rdf_content)
-        
-        # Determine primary class with most errors
-        primary_class = max(class_results.keys(), key=lambda k: len(class_results[k]))
-        focused_results = class_results[primary_class]
-        
-        # Extract only relevant RDF section for the primary class
+        if class_results:
+            primary_class = max(class_results.keys(), key=lambda k: len(class_results[k]))
+            focused_results = class_results[primary_class]
+        else:
+            primary_class = "Record"
+            focused_results = validation_results
+
+        simplified_summary = parse_shacl_results_for_ai(focused_results)
         relevant_rdf = extract_relevant_rdf_section(rdf_content, primary_class)
-        
-        prompt = f"""You are an expert in RDF/XML and SHACL validation. Analyze the validation errors for the {primary_class} class and provide CONCISE, ACTIONABLE fixes.
+
+        prompt = f"""
+You are a helpful metadata librarian. Write in plain language (no RDF/SHACL jargon). Analyze the validation errors for the {primary_class} and provide concise, actionable fixes.
 
 {severity_instruction}
 
 Validation Errors for {primary_class}:
 {focused_results[:1500]}
 
+Validation Summary (plain language):
+{simplified_summary}
+
 Relevant RDF Section:
 {relevant_rdf[:800]}
 
@@ -299,34 +296,35 @@ Format:
 ```
 
 Be ultra-concise. Show the fix, not explanations."""
-        
-        # Make API call using OpenAI client
-        print(f"🔄 Making focused API call for {primary_class} class")
-        print(f"🔄 Sending {len(focused_results)} chars instead of {len(validation_results)} chars")
-        
+
         chat_completion = client.chat.completions.create(
             model=HF_MODEL,
             messages=[
+                {
+                    "role": "system",
+                    "content": "You are a friendly librarian helping fix catalog records. Never use technical RDF or SHACL terminology."
+                },
                 {
                     "role": "user",
                     "content": prompt
                 }
             ],
-            max_tokens=800,  # Reduced since we're focused on one class
-            temperature=0.5,  # Lower temperature for more focused responses
+            max_tokens=800,
+            temperature=0.5,
             top_p=0.9
         )
-        
-        print("✅ API call successful")
+
         generated_text = chat_completion.choices[0].message.content
-        
-        # Add note about other classes if present
+        generated_text = clean_technical_jargon(generated_text)
+
         other_classes = [k for k in class_results.keys() if k != primary_class]
-        class_note = f"\n\n📌 **Note:** Focused on {primary_class} errors. " + \
-                     (f"Also found issues in: {', '.join(other_classes)}" if other_classes else "")
-        
+        class_note = (
+            f"\n\n📌 **Note:** Focused on {primary_class} errors. " +
+            (f"Also found issues in: {', '.join(other_classes)}" if other_classes else "")
+        )
+
         return f"🤖 **AI-Powered Suggestions ({('Violations + Warnings' if include_warnings else 'Violations Only')}):**\n\n{generated_text}{class_note}"
-        
+
     except Exception as e:
         logger.error(f"OpenAI/HF Inference Endpoint error: {str(e)}")
         return f"""
@@ -372,7 +370,7 @@ def extract_relevant_rdf_section(rdf_content: str, class_name: str) -> str:
     
     return rdf_content[:1000]  # Fallback
 
-def get_ai_correction(validation_results: str, rdf_content: str, template: str = 'monograph', max_attempts: int = None, include_warnings: bool = False) -> str:
+def get_ai_correction(validation_results: str, rdf_content: str, template: str = 'monograph', max_attempts: int = None, include_warnings: bool = False, enable_validation_loop: bool | None = None, steps_log: Optional[List[str]] = None) -> str:
     """
     Generate AI-powered corrected RDF/XML based on validation errors.
     
@@ -391,20 +389,31 @@ def get_ai_correction(validation_results: str, rdf_content: str, template: str =
         str: Corrected RDF/XML that should pass validation
     """
     
+    # Determine whether to iterate based on parameter or global default
+    iterate_enabled = ENABLE_VALIDATION_LOOP if enable_validation_loop is None else enable_validation_loop
+    if steps_log is not None:
+        steps_log.append(f"Planning correction: iterate_enabled={iterate_enabled}, include_warnings={include_warnings}")
     # Use configuration default if not specified
     if max_attempts is None:
         max_attempts = MAX_CORRECTION_ATTEMPTS
-    
-    # Check if validation loop is enabled
-    if not ENABLE_VALIDATION_LOOP:
-        max_attempts = 1  # Fall back to single attempt if validation loop disabled
+    if steps_log is not None:
+        steps_log.append(f"Max attempts set to {max_attempts}")
+    # If iteration disabled, force single attempt
+    if not iterate_enabled:
+        max_attempts = 1
+        if steps_log is not None:
+            steps_log.append("Iteration disabled; forcing single attempt")
     
     if not OPENAI_AVAILABLE:
+        if steps_log is not None:
+            steps_log.append("OPENAI client not available; falling back to manual hints")
         return generate_manual_correction_hints(validation_results, rdf_content)
     
     # Get API key dynamically at runtime
     current_api_key = os.getenv('HF_API_KEY', '')
     if not current_api_key:
+        if steps_log is not None:
+            steps_log.append("HF_API_KEY not set; cannot call model; returning manual hints")
         return f"""<!-- AI correction disabled: Set HF_API_KEY as a Secret in your Space settings -->
 
 {generate_manual_correction_hints(validation_results, rdf_content)}"""
@@ -412,6 +421,8 @@ def get_ai_correction(validation_results: str, rdf_content: str, template: str =
     try:
         client = get_openai_client()
         if not client:
+            if steps_log is not None:
+                steps_log.append("Failed to initialize OpenAI client; returning manual hints")
             return f"""<!-- AI correction disabled: HF_API_KEY not configured -->
 
 {generate_manual_correction_hints(validation_results, rdf_content)}"""
@@ -420,6 +431,8 @@ def get_ai_correction(validation_results: str, rdf_content: str, template: str =
         import time
         start_time = time.time()
         timeout = 60  # 60 second timeout
+        if steps_log is not None:
+            steps_log.append(f"Timeout budget: {timeout}s total")
         
         severity_instruction = "Fix only the violations (errors) and ignore any warnings." if not include_warnings else "Fix both violations and warnings."
         
@@ -661,7 +674,7 @@ def extract_rdf_from_response(response: str) -> str:
     # If no code blocks found, return the response as-is
     return response
 
-def get_ai_correction(validation_results: str, rdf_content: str, template: str = 'monograph', max_attempts: int = None, include_warnings: bool = False) -> str:
+def get_ai_correction(validation_results: str, rdf_content: str, template: str = 'monograph', max_attempts: int = None, include_warnings: bool = False, enable_validation_loop: bool | None = None, steps_log: Optional[List[str]] = None) -> str:
     """
     Generate AI-powered corrected RDF/XML based on validation errors.
     
@@ -680,20 +693,31 @@ def get_ai_correction(validation_results: str, rdf_content: str, template: str =
         str: Corrected RDF/XML that should pass validation
     """
     
+    # Determine whether to iterate based on parameter or global default
+    iterate_enabled = ENABLE_VALIDATION_LOOP if enable_validation_loop is None else enable_validation_loop
+    if steps_log is not None:
+        steps_log.append(f"Planning correction: iterate_enabled={iterate_enabled}, include_warnings={include_warnings}")
     # Use configuration default if not specified
     if max_attempts is None:
         max_attempts = MAX_CORRECTION_ATTEMPTS
-    
-    # Check if validation loop is enabled
-    if not ENABLE_VALIDATION_LOOP:
-        max_attempts = 1  # Fall back to single attempt if validation loop disabled
+    if steps_log is not None:
+        steps_log.append(f"Max attempts set to {max_attempts}")
+    # If iteration disabled, force single attempt
+    if not iterate_enabled:
+        max_attempts = 1
+        if steps_log is not None:
+            steps_log.append("Iteration disabled; forcing single attempt")
     
     if not OPENAI_AVAILABLE:
+        if steps_log is not None:
+            steps_log.append("OPENAI client not available; falling back to manual hints")
         return generate_manual_correction_hints(validation_results, rdf_content)
     
     # Get API key dynamically at runtime
     current_api_key = os.getenv('HF_API_KEY', '')
     if not current_api_key:
+        if steps_log is not None:
+            steps_log.append("HF_API_KEY not set; cannot call model; returning manual hints")
         return f"""<!-- AI correction disabled: Set HF_API_KEY as a Secret in your Space settings -->
 
 {generate_manual_correction_hints(validation_results, rdf_content)}"""
@@ -701,6 +725,8 @@ def get_ai_correction(validation_results: str, rdf_content: str, template: str =
     try:
         client = get_openai_client()
         if not client:
+            if steps_log is not None:
+                steps_log.append("Failed to initialize OpenAI client; returning manual hints")
             return f"""<!-- AI correction disabled: HF_API_KEY not configured -->
 
 {generate_manual_correction_hints(validation_results, rdf_content)}"""
@@ -709,17 +735,25 @@ def get_ai_correction(validation_results: str, rdf_content: str, template: str =
         import time
         start_time = time.time()
         timeout = 60  # 60 second timeout
+        if steps_log is not None:
+            steps_log.append(f"Timeout budget: {timeout}s total")
         
         severity_instruction = "Fix only the violations (errors) and ignore any warnings." if not include_warnings else "Fix both violations and warnings."
         
         # Try multiple attempts to generate valid RDF
         for attempt in range(max_attempts):
             # Check timeout
-            if time.time() - start_time > timeout:
+            elapsed = time.time() - start_time
+            if elapsed > timeout:
+                if steps_log is not None:
+                    steps_log.append(f"Timeout reached after {int(elapsed)}s; stopping attempts")
                 print(f"⏰ Timeout reached after {timeout} seconds")
                 break
                 
-            print(f"🔄 Correction attempt {attempt + 1}/{max_attempts}")
+            attempt_no = attempt + 1
+            if steps_log is not None:
+                steps_log.append(f"Attempt {attempt_no}/{max_attempts}: requesting model correction")
+            print(f"🔄 Correction attempt {attempt_no}/{max_attempts}")
             
             prompt = f"""You are an expert in RDF/XML. Fix the following RDF/XML based on the validation errors provided.
 
@@ -755,6 +789,8 @@ Please provide the corrected RDF/XML that addresses all validation issues.
                 )
                 
                 corrected_rdf = chat_completion.choices[0].message.content.strip()
+                if steps_log is not None:
+                    steps_log.append(f"Attempt {attempt_no}: model responded; extracting XML block if present")
                 
                 # Extract RDF content if it's wrapped in code blocks
                 corrected_rdf = extract_rdf_from_response(corrected_rdf)
@@ -766,32 +802,44 @@ Please provide the corrected RDF/XML that addresses all validation issues.
                         conforms, new_results = validate_rdf(corrected_rdf.encode('utf-8'), template)
                         
                         if conforms:
-                            print(f"✅ Correction validated successfully on attempt {attempt + 1}")
+                            if steps_log is not None:
+                                steps_log.append(f"Attempt {attempt_no}: correction PASSED validation")
+                            print(f"✅ Correction validated successfully on attempt {attempt_no}")
                             return f"""<!-- AI-generated correction validated successfully -->
 {corrected_rdf}"""
                         else:
-                            print(f"❌ Correction attempt {attempt + 1} still has validation errors")
+                            if steps_log is not None:
+                                steps_log.append(f"Attempt {attempt_no}: still invalid; will retry with updated errors")
+                            print(f"❌ Correction attempt {attempt_no} still has validation errors")
                             # Update validation_results for next attempt
                             validation_results = new_results
                             
                     except Exception as e:
-                        print(f"⚠️ Error validating correction attempt {attempt + 1}: {str(e)}")
+                        if steps_log is not None:
+                            steps_log.append(f"Attempt {attempt_no}: error during validation: {str(e)} — returning correction anyway")
+                        print(f"⚠️ Error validating correction attempt {attempt_no}: {str(e)}")
                         # If validation fails, return the correction anyway
                         return f"""<!-- AI-generated correction (validation check failed) -->
 {corrected_rdf}"""
                 else:
                     # If validator not available or timeout approaching, return the correction
+                    if steps_log is not None:
+                        steps_log.append("Skipping validation check (validator unavailable or timeout)")
                     print("⚠️ Returning correction without validation")
                     return f"""<!-- AI-generated correction (validation skipped) -->
 {corrected_rdf}"""
                     
             except Exception as api_error:
-                print(f"❌ API error on attempt {attempt + 1}: {str(api_error)}")
+                if steps_log is not None:
+                    steps_log.append(f"Attempt {attempt_no}: API error: {str(api_error)}")
+                print(f"❌ API error on attempt {attempt_no}: {str(api_error)}")
                 if attempt == max_attempts - 1:  # Last attempt
                     raise api_error
                 continue
         
         # All attempts failed or timed out
+        if steps_log is not None:
+            steps_log.append("All attempts failed or timed out; returning manual hints")
         return f"""<!-- AI correction failed after {max_attempts} attempts or timeout -->
 <!-- Please correct manually using the validation results as a guide -->
 
@@ -799,6 +847,8 @@ Please provide the corrected RDF/XML that addresses all validation issues.
         
     except Exception as e:
         logger.error(f"LLM API error: {str(e)}")
+        if steps_log is not None:
+            steps_log.append(f"Fatal error invoking model: {str(e)}")
         return f"""<!-- Error generating AI correction: {str(e)} -->
 
 {generate_manual_correction_hints(validation_results, rdf_content)}"""
@@ -972,7 +1022,7 @@ def extract_xml_from_text(text: str) -> str:
     fenced = re.sub(r"^```[a-zA-Z]*\n|```$", "", text.strip())
     return fenced if fenced else text
 
-def validate_rdf_interface(rdf_content: str, template: str, use_ai: bool = True):
+def validate_rdf_interface(rdf_content: str, template: str, use_ai: bool = True, include_warnings: bool = False, iterate_until_valid: bool = False, max_attempts: int = 3, show_steps: bool = False):
     """Main validation function for Gradio interface"""
     if not rdf_content.strip():
         return "❌ Error", "No RDF/XML data provided", "", "", "", ""
@@ -981,7 +1031,7 @@ def validate_rdf_interface(rdf_content: str, template: str, use_ai: bool = True)
     result = validate_rdf_tool(rdf_content, template)
     
     if "error" in result:
-        return f"❌ Error: {result['error']}", "", "", "", "", ""
+        return f"❌ Error: {result['error']}", "", "", "", "", "", ""
     
     status = result["status"]
     results_text = result["results"]
@@ -1005,19 +1055,59 @@ def validate_rdf_interface(rdf_content: str, template: str, use_ai: bool = True)
         
         filtered_results = '\n'.join(filtered_lines)
     
+    corrected_status = ""
+    corrected_results = ""
+    steps_log: List[str] = []
+    steps_log.append(f"Initial validation: {'PASSED' if result['conforms'] else 'FAILED'} using template '{template}'")
+    if not include_warnings:
+        steps_log.append("Configured to ignore warnings in AI processing")
+    if iterate_until_valid:
+        steps_log.append(f"Iteration enabled with max_attempts={max_attempts}")
     if result["conforms"]:
         suggestions = "✅ No issues found! Your RDF/XML is valid according to the selected template."
-        corrected_rdf = "✅ Your RDF/XML is already valid - no corrections needed!"
+        corrected_rdf = "<!-- Already valid - no corrections needed -->\n" + rdf_content
+        corrected_status = "—"
+        corrected_results = ""
+        steps_log.append("No correction needed; record already conforms")
     else:
         if use_ai:
             # Pass filtered results to AI functions
             suggestions = get_ai_suggestions(filtered_results, rdf_content, include_warnings)
-            corrected_rdf = get_ai_correction(filtered_results, rdf_content, template, include_warnings=include_warnings)
+            steps_log.append("Requested AI suggestions for concise guidance")
+            corrected_rdf = get_ai_correction(
+                filtered_results,
+                rdf_content,
+                template,
+                max_attempts=max_attempts,
+                include_warnings=include_warnings,
+                enable_validation_loop=iterate_until_valid,
+                steps_log=steps_log,
+            )
+            # Attempt re-validation of corrected RDF
+            try:
+                corrected_xml = extract_xml_from_text(corrected_rdf)
+                reval = validate_rdf_tool(corrected_xml, template)
+                if "error" in reval:
+                    corrected_status = f"❌ Re-validation Error: {reval['error']}"
+                    corrected_results = ""
+                    steps_log.append(f"Re-validation failed with error: {reval['error']}")
+                else:
+                    corrected_status = reval.get("status", "")
+                    corrected_results = reval.get("results", "")
+                    steps_log.append(f"Re-validation: {corrected_status}")
+            except Exception as re_ex:
+                corrected_status = f"❌ Re-validation Error: {re_ex}"
+                corrected_results = ""
+                steps_log.append(f"Re-validation error: {re_ex}")
         else:
             suggestions = generate_manual_suggestions(filtered_results)
             corrected_rdf = generate_manual_correction_hints(filtered_results, rdf_content)
+            corrected_status = "—"
+            corrected_results = ""
+            steps_log.append("AI disabled; produced manual suggestions and hints")
     
-    return status, results_text, suggestions, corrected_rdf
+    steps_text = "\n".join(steps_log) if show_steps else ""
+    return status, results_text, suggestions, steps_text, corrected_rdf, corrected_status, corrected_results
 
 def get_rdf_examples(example_type: str = "valid") -> str:
     """
@@ -1145,6 +1235,26 @@ def create_interface():
                         value=False,
                         info="Include warnings in AI corrections (violations only by default)"
                     )
+
+                with gr.Row():
+                    iterate_checkbox = gr.Checkbox(
+                        label="Iterate until valid",
+                        value=False,
+                        info="Try multiple correction attempts until validation passes or attempts run out"
+                    )
+                    max_attempts_slider = gr.Slider(
+                        label="Max attempts",
+                        minimum=1,
+                        maximum=5,
+                        value=3,
+                        step=1,
+                        info="Maximum number of correction attempts when iterating"
+                    )
+                    show_steps_checkbox = gr.Checkbox(
+                        label="Show steps",
+                        value=True,
+                        info="Display step-by-step process (turn off for a simpler response)"
+                    )
                 
                 validate_btn = gr.Button("🔍 Validate RDF", variant="primary", size="lg")
                 
@@ -1181,6 +1291,14 @@ def create_interface():
                     lines=8,
                     show_copy_button=True
                 )
+
+                steps_output = gr.Textbox(
+                    label="🧭 Correction Steps",
+                    interactive=False,
+                    lines=10,
+                    show_copy_button=True,
+                    placeholder="Step-by-step log of how the system derived the corrected XML"
+                )
         
         # Corrected RDF section
         with gr.Row():
@@ -1212,8 +1330,8 @@ def create_interface():
         # Event handlers
         validate_btn.click(
             fn=validate_rdf_interface,
-            inputs=[rdf_input, template_dropdown, use_ai_checkbox, include_warnings_checkbox],
-            outputs=[status_output, results_output, suggestions_output, corrected_output]
+            inputs=[rdf_input, template_dropdown, use_ai_checkbox, include_warnings_checkbox, iterate_checkbox, max_attempts_slider, show_steps_checkbox],
+            outputs=[status_output, results_output, suggestions_output, steps_output, corrected_output, corrected_status_output, corrected_results_output]
         )
         
         # Remove auto-validation to prevent processing loops
@@ -1235,8 +1353,8 @@ def create_interface():
         )
         
         clear_btn.click(
-            lambda: ("", "", "", "", "", "", ""),
-            outputs=[rdf_input, status_output, results_output, suggestions_output, corrected_output, corrected_status_output, corrected_results_output]
+            lambda: ("", "", "", "", "", "", "", ""),
+            outputs=[rdf_input, status_output, results_output, suggestions_output, steps_output, corrected_output, corrected_status_output, corrected_results_output]
         )
         
         # Footer with instructions