Skip generating corrected XML when input is already valid; add namespace/wrapper guard for snippets; fix UI wiring; revalidation uses wrapped XML.

app.py

@@ -1022,13 +1022,93 @@ def extract_xml_from_text(text: str) -> str:
     fenced = re.sub(r"^```[a-zA-Z]*\n|```$", "", text.strip())
     return fenced if fenced else text
 
+# --- Namespace and wrapper helpers to avoid XML parser errors ---
+STANDARD_NAMESPACES = {
+    "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+    "bf": "http://id.loc.gov/ontologies/bibframe/",
+    "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
+    "xsd": "http://www.w3.org/2001/XMLSchema#",
+}
+
+def _extract_declared_namespaces(xml_text: str) -> dict:
+    import re
+    decls = {}
+    for prefix, uri in re.findall(r"xmlns:([A-Za-z0-9_-]+)=\"([^\"]+)\"", xml_text[:2000]):
+        decls[prefix] = uri
+    return decls
+
+def _detect_used_prefixes(xml_text: str) -> set:
+    import re
+    used = set()
+    # Tag prefixes like <bf:Work ...> and attribute prefixes like rdf:type="..."
+    for m in re.finditer(r"<\s*([A-Za-z0-9_-]+):[A-Za-z0-9_-]+", xml_text):
+        used.add(m.group(1))
+    for m in re.finditer(r"\s([A-Za-z0-9_-]+):[A-Za-z0-9_-]+=", xml_text):
+        used.add(m.group(1))
+    return used
+
+def ensure_rdf_wrapper_and_namespaces(xml_text: str, original_text: Optional[str] = None, steps_log: Optional[List[str]] = None) -> str:
+    """Ensure the XML has an <rdf:RDF> wrapper and required xmlns declarations for used prefixes.
+
+    - If wrapper exists, add any missing xmlns: declarations for standard, used prefixes.
+    - If wrapper is missing, wrap the content and include standard namespaces for used prefixes.
+    """
+    if not xml_text or not isinstance(xml_text, str):
+        return xml_text
+    import re
+
+    declared = _extract_declared_namespaces(xml_text)
+    if original_text:
+        # Merge any declarations present in the original input
+        declared.update(_extract_declared_namespaces(original_text))
+
+    used = _detect_used_prefixes(xml_text)
+    # Always consider rdf used for wrapper
+    used.add("rdf")
+
+    # Only inject namespaces for known standards to avoid guessing
+    missing = [p for p in used if p not in declared and p in STANDARD_NAMESPACES]
+    added_attrs = " ".join([f"xmlns:{p}=\"{STANDARD_NAMESPACES[p]}\"" for p in missing])
+
+    has_wrapper = bool(re.search(r"<rdf:RDF[^>]*>", xml_text))
+    updated = xml_text
+
+    if has_wrapper:
+        if added_attrs:
+            # Inject before the closing '>' of the first <rdf:RDF ...>
+            def _inject(match):
+                start_tag = match.group(0)
+                if start_tag.endswith('>'):
+                    return start_tag[:-1] + ' ' + added_attrs + '>'
+                return start_tag + ' ' + added_attrs
+            updated = re.sub(r"<rdf:RDF[^>]*>", _inject, updated, count=1)
+            if steps_log is not None and missing:
+                steps_log.append(f"Injected missing namespace declarations: {', '.join(missing)}")
+    else:
+        # Build a wrapper with standard namespaces for used prefixes we know
+        attrs = [f"xmlns:rdf=\"{STANDARD_NAMESPACES['rdf']}\""]
+        for p in used:
+            if p == 'rdf':
+                continue
+            uri = declared.get(p) or STANDARD_NAMESPACES.get(p)
+            if uri:
+                attrs.append(f"xmlns:{p}=\"{uri}\"")
+        wrapper_open = "<rdf:RDF " + " ".join(attrs) + ">\n"
+        wrapper_close = "\n</rdf:RDF>"
+        updated = wrapper_open + xml_text + wrapper_close
+        if steps_log is not None:
+            steps_log.append("Wrapped snippet in <rdf:RDF> with standard namespace declarations")
+
+    return updated
+
 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", "", "", "", ""
+        return "❌ Error", "No RDF/XML data provided", "", "", "", "", ""
 
     # Validate RDF
-    result = validate_rdf_tool(rdf_content, template)
+    prepped_input = ensure_rdf_wrapper_and_namespaces(rdf_content)
+    result = validate_rdf_tool(prepped_input, template)
     
     if "error" in result:
         return f"❌ Error: {result['error']}", "", "", "", "", "", ""
@@ -1065,7 +1145,7 @@ def validate_rdf_interface(rdf_content: str, template: str, use_ai: bool = True,
         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 = "<!-- Already valid - no corrections needed -->\n" + rdf_content
+        corrected_rdf = ""
         corrected_status = "—"
         corrected_results = ""
         steps_log.append("No correction needed; record already conforms")
@@ -1086,6 +1166,7 @@ def validate_rdf_interface(rdf_content: str, template: str, use_ai: bool = True,
             # Attempt re-validation of corrected RDF
             try:
                 corrected_xml = extract_xml_from_text(corrected_rdf)
+                corrected_xml = ensure_rdf_wrapper_and_namespaces(corrected_xml, original_text=prepped_input, steps_log=steps_log)
                 reval = validate_rdf_tool(corrected_xml, template)
                 if "error" in reval:
                     corrected_status = f"❌ Re-validation Error: {reval['error']}"
@@ -1223,7 +1304,7 @@ def create_interface():
                         value="monograph",
                         info="Select the SHACL template to validate against"
                     )
-                    
+
                     use_ai_checkbox = gr.Checkbox(
                         label="Use AI Features",
                         value=True,