@miller-tech/uap 1.0.0

package/tools/agents/scripts/fix_qwen_chat_template.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+"""
+Qwen Chat Template Auto-Fixer & Verifier
+
+Automatically detects and fixes common chat template issues,
+verifies the fixed template works with Jinja2 parser.
+
+Usage:
+    python3 fix_qwen_chat_template.py [template_path]
+
+Auto-detection looks for templates in standard locations relative to project root.
+"""
+
+import sys
+import os
+import re
+from pathlib import Path
+from datetime import datetime
+
+
+def find_project_root():
+    """Find the UAP project root directory."""
+    current = Path(__file__).resolve().parent
+
+    # Walk up from script location until we find package.json or .git
+    for parent in [current] + list(current.parents):
+        if (parent / "package.json").exists() or (parent / ".git" / "config").exists():
+            return parent
+
+    return current
+
+
+def find_chat_templates(project_root=None):
+    """Find all chat template files in project."""
+    if not project_root:
+        project_root = find_project_root()
+
+    templates = []
+
+    # Standard locations to check (in priority order)
+    search_paths = [
+        project_root / "tools" / "agents" / "config",
+        project_root,
+    ]
+
+    for search_path in search_paths:
+        if not search_path.exists():
+            continue
+
+        for pattern in ["chat_template.jinja", "*qwen*.jinja"]:
+            for found in search_path.glob(pattern):
+                # Skip backup files
+                if ".backup." in found.name:
+                    continue
+                templates.append(found)
+
+    # Deduplicate and sort by path length (prefer deeper/more specific paths)
+    seen = set()
+    unique = []
+    for t in templates:
+        resolved = t.resolve()
+        if resolved not in seen:
+            seen.add(resolved)
+            unique.append(t)
+
+    # Sort: prefer tools/agents/config/ over root
+    return sorted(unique, key=lambda x: (0 if "tools" in str(x) else 1, len(str(x))))
+
+
+def validate_template_syntax(content):
+    """Validate Jinja2 template syntax with correct regex patterns."""
+    issues = []
+
+    # Count balanced blocks using correct Jinja2 syntax
+    # Opening: {% if ... %}, {%- if ... %}, {%- if ... -%}
+    # Closing: {% endif %}, {%- endif %}, {%- endif -%}
+    block_pairs = [
+        ("if", r"\{%-?\s*if\s+", r"\{%-?\s*endif\s*-?%\}"),
+        ("for", r"\{%-?\s*for\s+", r"\{%-?\s*endfor\s*-?%\}"),
+        ("macro", r"\{%-?\s*macro\s+", r"\{%-?\s*endmacro\s*-?%\}"),
+    ]
+
+    for tag_name, open_pattern, close_pattern in block_pairs:
+        opens = len(re.findall(open_pattern, content))
+        closes = len(re.findall(close_pattern, content))
+
+        if opens != closes:
+            issues.append(
+                f"Unbalanced {tag_name} blocks: {opens} open vs {closes} close"
+            )
+
+    # Check for broken tag syntax
+    # Valid: {%- elif %}, {% elif %}, {%- elif -%}
+    # Invalid: {-% elif %}, {%{%- elif %}
+    broken_tags = re.findall(r"\{-?%[^}]*%\}", content)
+    for tag in broken_tags:
+        if tag.startswith("{-%") and not tag.startswith("{%-"):
+            issues.append(f"Invalid tag syntax: {tag[:40]}...")
+
+    # Check for double-opened tags like {%- {%- elif %}
+    double_opens = re.findall(r"\{%-?\s*\{%-?", content)
+    if double_opens:
+        issues.append(f"Found {len(double_opens)} double-opened tags")
+
+    # Check for stray endmacro without macro
+    macros = len(re.findall(r"\{%-?\s*macro\s+", content))
+    endmacros = len(re.findall(r"\{%-?\s*endmacro\s*-?%\}", content))
+    if endmacros > macros:
+        issues.append(f"Found {endmacros - macros} stray endmacro tag(s)")
+
+    return issues
+
+
+def verify_template_with_jinja(template_content):
+    """Verify template can be parsed by Jinja2."""
+    try:
+        from jinja2 import Environment, BaseLoader
+        import json
+
+        env = Environment(loader=BaseLoader())
+
+        # Try to compile the template
+        template = env.from_string(template_content)
+
+        # Test with minimal valid input
+        test_data = {
+            "messages": [
+                {"role": "system", "content": "Test system message"},
+                {"role": "user", "content": "Hello"},
+            ],
+            "add_generation_prompt": True,
+            "enable_thinking": False,
+        }
+
+        try:
+            result = template.render(**test_data)
+            print(f"  [OK] Template compiled and rendered ({len(result)} chars)")
+
+            # Test tool call round-trip
+            test_tool_data = {
+                "messages": [
+                    {"role": "user", "content": "Read file"},
+                    {
+                        "role": "assistant",
+                        "content": "",
+                        "tool_calls": [
+                            {
+                                "function": {
+                                    "name": "read_file",
+                                    "arguments": json.dumps({"path": "/etc/hosts"}),
+                                }
+                            }
+                        ],
+                    },
+                    {
+                        "role": "tool",
+                        "name": "read_file",
+                        "content": "127.0.0.1 localhost",
+                    },
+                ],
+                "add_generation_prompt": True,
+                "enable_thinking": False,
+            }
+
+            result2 = template.render(**test_tool_data)
+            if "<tool_call>" in result2 and '"name"' in result2:
+                print("  [OK] Tool call format verified (official Qwen3 format)")
+            elif "<function_call>" in result2 and "<tool_name>" in result2:
+                print("  [OK] Tool call format verified (legacy XML format)")
+            elif "<function=" in result2:
+                print("  [OK] Tool call format verified (function= style)")
+            else:
+                print("  [WARN] Tool call tags not found in output")
+
+            return True
+
+        except Exception as e:
+            error_msg = str(e)
+            if "undefined" in error_msg.lower():
+                # Variable undefined is expected with minimal test data
+                print(f"  [OK] Template parsed (expected variable: {error_msg[:60]})")
+                return True
+            else:
+                print(f"  [FAIL] Render error: {error_msg[:100]}")
+                return False
+
+    except ImportError:
+        print("  [SKIP] Jinja2 not installed (pip install jinja2)")
+        return None
+    except Exception as e:
+        error_msg = str(e)
+        line_match = re.search(r"line (\d+)", error_msg)
+
+        if line_match:
+            line_num = int(line_match.group(1))
+            lines = template_content.split("\n")
+            print(f"\n  [FAIL] Error at line {line_num}:")
+            start = max(0, line_num - 3)
+            for i in range(start, min(line_num + 2, len(lines))):
+                marker = ">>>" if i == line_num - 1 else "   "
+                print(f"  {marker} {i + 1}: {lines[i][:80]}")
+        else:
+            print(f"\n  [FAIL] Template parsing error: {error_msg[:200]}")
+
+        return False
+
+
+def main():
+    """Main execution with auto-detection."""
+
+    print("=" * 70)
+    print("Qwen Chat Template Verifier")
+    print("=" * 70)
+
+    # Get project root
+    project_root = find_project_root()
+    print(f"\nProject root: {project_root}")
+
+    # Handle explicit path argument
+    if len(sys.argv) > 1:
+        target_template = Path(sys.argv[1])
+        if not target_template.exists():
+            print(f"Error: File not found: {target_template}")
+            sys.exit(1)
+    else:
+        # Find templates automatically
+        print("\nSearching for chat templates...")
+        templates = find_chat_templates(project_root)
+
+        if not templates:
+            print("Error: No chat template files found!")
+            print(
+                f"\nExpected at: {project_root / 'tools' / 'agents' / 'config' / 'chat_template.jinja'}"
+            )
+            sys.exit(1)
+
+        target_template = templates[0]
+
+    try:
+        rel_path = target_template.relative_to(project_root)
+    except ValueError:
+        rel_path = target_template
+
+    print(f"Using: {rel_path}")
+
+    # Read content
+    try:
+        with open(target_template, "r", encoding="utf-8") as f:
+            content = f.read()
+        print(f"Loaded: {len(content)} bytes, {len(content.splitlines())} lines")
+    except Exception as e:
+        print(f"Error reading {target_template}: {e}")
+        sys.exit(1)
+
+    # Validate syntax
+    print("\nValidating template syntax...")
+    issues = validate_template_syntax(content)
+
+    if issues:
+        print(f"  Found {len(issues)} issue(s):")
+        for issue in issues:
+            print(f"    - {issue}")
+    else:
+        print("  [OK] No syntax issues detected")
+
+    # Verify with Jinja2
+    print("\nVerifying with Jinja2 parser...")
+    jinja_ok = verify_template_with_jinja(content)
+
+    if jinja_ok is True:
+        print("\n[OK] Template is valid and functional")
+    elif jinja_ok is False:
+        print("\n[FAIL] Template has errors - needs manual review")
+        sys.exit(1)
+    else:
+        print("\n[SKIP] Could not verify (install jinja2: pip install jinja2)")
+
+    # Show template features
+    print("\nTemplate features:")
+    features = [
+        ("System message handling", "role == 'system'" in content),
+        ("User message handling", "role == 'user'" in content),
+        ("Assistant message handling", "role == 'assistant'" in content),
+        ("Tool call support", "tool_calls" in content or "tool_call" in content),
+        ("Native tool descriptions", "for tool in tools" in content),
+        (
+            "Tool response support",
+            "role == 'tool'" in content or "tool_response" in content,
+        ),
+        (
+            "Thinking/reasoning mode",
+            "thinking" in content.lower() or "think" in content.lower(),
+        ),
+        ("ChatML format (<|im_start|>)", "<|im_start|>" in content),
+        ("Generation prompt", "add_generation_prompt" in content),
+    ]
+
+    for feature, has_it in features:
+        status = "[OK]" if has_it else "[--]"
+        print(f"  {status} {feature}")
+
+    print("\n" + "=" * 70)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\nInterrupted")
+        sys.exit(130)
+    except Exception as e:
+        import traceback
+
+        print(f"\nUnexpected error: {e}")
+        traceback.print_exc()
+        sys.exit(1)