Update grader and inference

graders.py

@@ -20,10 +20,57 @@ def _normalize_issue(issue: Dict[str, Any]) -> Issue:
 
 
 def _match_issue(pred: Issue, expected: Issue) -> bool:
-    if pred.issue_type.lower() != expected.issue_type.lower():
-        return False
-    if pred.severity.lower() != expected.severity.lower():
-        return False
+    pred_type = pred.issue_type.lower()
+    exp_type = expected.issue_type.lower()
+    
+    type_variations = {
+        "missing_spdx": ["spdx", "license", "licensing"],
+        "old_compiler_version": ["compiler", "pragma", "version"],
+        "missing_natspec": ["natspec", "documentation", "doc comment"],
+        "deprecated_constructor": ["constructor", "deprecated"],
+        "unbounded_loop": ["loop", "unbounded", "dynamic array"],
+        "redundant_storage_read": ["storage read", "redundant", "cache", "sload", "repeated storage"],
+        "custom_error_missing": ["custom error", "require string"],
+        "reentrancy": ["reentrancy", "re-entrancy", "re-entry"],
+        "missing_access_control": ["access control", "authorization", "owner only"],
+        "tx_origin_auth": ["tx.origin", "tx origin"],
+    }
+    
+    matched_type = True
+    if pred_type != exp_type:
+        matched_type = False
+        if exp_type in type_variations:
+            for variation in type_variations[exp_type]:
+                if variation in pred_type or pred_type in variation:
+                    matched_type = True
+                    break
+        if not matched_type:
+            for key, variations in type_variations.items():
+                for v in variations:
+                    if v in pred_type and v in exp_type:
+                        matched_type = True
+                        break
+                if matched_type:
+                    break
+        if not matched_type:
+            return False
+    
+    pred_sev = pred.severity.lower()
+    exp_sev = expected.severity.lower()
+    
+    severity_map = {
+        "critical": ["critical", "high", "severe", "danger", "major", "important"],
+        "medium": ["medium", "moderate", "warning", "medium-high", "average"],
+        "low": ["low", "minor", "informational", "info", "minor issue", "cosmetic"],
+        "info": ["info", "information", "low", "informational", "note"],
+    }
+    
+    if pred_sev != exp_sev:
+        if exp_sev in severity_map:
+            matched_sev = any(s in pred_sev for s in severity_map[exp_sev])
+            if not matched_sev:
+                return False
+    
     return True
 
 
@@ -75,4 +122,4 @@ def grade_action(action: List[Dict[str, Any]], expected: List[Dict[str, Any]]) -
         "line_bonus": round(min(line_bonus_total, 0.2), 3),
         "score": round(score, 4),
     }
-    return score, details
+    return score, details

inference.py

@@ -9,7 +9,7 @@ from environment import SolidityGuardEnv
 
 
 def _log(tag: str, payload: Dict[str, Any]) -> None:
-    print(f"[{tag}] {json.dumps(payload, ensure_ascii=True)}")
+    print(f"[{tag}] {json.dumps(payload, ensure_ascii=False)}")
 
 
 def _load_env_var(name: str) -> str:
@@ -26,18 +26,30 @@ def _call_model(prompt: str) -> List[Dict[str, Any]]:
     model_name = _load_env_var("MODEL_NAME")
     hf_token = _load_env_var("HF_TOKEN")
 
-    client = OpenAI(base_url=api_base_url, api_key=hf_token)
-    response = client.chat.completions.create(
-        model=model_name,
-        messages=[
-            {"role": "system", "content": "You are a Solidity security reviewer."},
-            {"role": "user", "content": prompt},
-        ],
-        temperature=0.0,
-        max_tokens=800,
-    )
+    try:
+        client = OpenAI(base_url=api_base_url, api_key=hf_token)
+        response = client.chat.completions.create(
+            model=model_name,
+            messages=[
+                {"role": "system", "content": "You are a Solidity security reviewer. Always respond with valid JSON array only, no explanations."},
+                {"role": "user", "content": prompt},
+            ],
+            temperature=0.1,
+            max_tokens=1024,
+        )
 
-    content = response.choices[0].message.content or "[]"
+        content = response.choices[0].message.content or "[]"
+    except Exception:
+        content = "[]"
+    
+    if content.startswith("```"):
+        parts = content.split("```")
+        if len(parts) >= 3:
+            content = parts[1]
+            if content.startswith("json"):
+                content = content[4:]
+            content = content.strip()
+    
     try:
         parsed = json.loads(content)
     except json.JSONDecodeError:
@@ -48,10 +60,15 @@ def _call_model(prompt: str) -> List[Dict[str, Any]]:
 
 
 def _build_prompt(source_code: str, task_id: str) -> str:
+    task_info = {
+        "task_1_best_practices": "Find syntax and best-practice issues: missing SPDX license, old compiler version (<0.8.x), missing NatSpec comments, deprecated constructor syntax.",
+        "task_2_gas_optimization": "Find gas optimization opportunities: unbounded loops, redundant storage reads, missing custom errors (use custom errors instead of require strings).",
+        "task_3_security": "Find security vulnerabilities: reentrancy bugs, missing access control, tx.origin usage for authorization, integer overflow/underflow.",
+    }
     return (
         "Review the Solidity contract and return a JSON array of findings. "
-        "Each finding must include: issue_type, line_number, description, severity. "
-        f"Task: {task_id}.\n\n"
+        "Each finding must include: issue_type, line_number, description, severity (Critical/Medium/Low/Info). "
+        f"Focus on: {task_info.get(task_id, task_id)}\n\n"
         f"Contract:\n{source_code}"
     )
 
@@ -97,4 +114,4 @@ if __name__ == "__main__":
         sys.exit(run())
     except Exception as exc:
         _log("END", {"final_score": 0.0, "error": str(exc)})
-        sys.exit(1)
+        sys.exit(1)