fix /tasks endpoint format for validator

server.log

@@ -0,0 +1,2 @@
+nohup: ignoring input
+ERROR:    Error loading ASGI app. Could not import module "app".

sql_env/env.py

@@ -69,7 +69,7 @@ class SQLCorrectionEnv:
         if abs(reward - self._last_reward) < 0.01 and self._step_count > 1:
             self._stagnation_count += 1
             if self._stagnation_count >= 2:
-                reward = max(0.0, reward - 0.1)  # stagnation penalty
+                reward = max(0.001, reward - 0.1)  # stagnation penalty
         else:
             self._stagnation_count = 0
 
@@ -81,7 +81,7 @@ class SQLCorrectionEnv:
         self._previous_attempt = action.corrected_query
 
         # episode ends on perfect score or max steps reached
-        done = reward_model.value == 1.0 or self._step_count >= self._task.max_steps
+        done = reward_model.value >= 0.99 or self._step_count >= self._task.max_steps
         self._done = done
 
         obs = self._make_observation()

sql_env/grader.py

@@ -2,6 +2,11 @@ import re
 from sql_env.models import SQLAction, SQLTask, SQLReward
 
 
+def _clamp(value: float) -> float:
+    """Ensure score is strictly between 0 and 1 (gt=0.0, lt=1.0)."""
+    return max(0.001, min(0.999, value))
+
+
 def _normalize(query: str) -> str:
     """Uppercase, collapse whitespace, strip trailing semicolons."""
     q = query.strip().upper()
@@ -11,7 +16,9 @@ def _normalize(query: str) -> str:
 
 
 def _tokenize(query: str) -> set:
-    return set(re.findall(r"[A-Z0-9_'*.=><]+", _normalize(query)))
+    normed = _normalize(query)
+    normed = re.sub(r"'[^']*'", '__STR__', normed)  # normalize string literals
+    return set(re.findall(r"[A-Z0-9_'*.=><]+", normed))
 
 
 def _sql_keywords_present(query: str) -> set:
@@ -33,26 +40,29 @@ def _sql_keywords_present(query: str) -> set:
 def grade(action: SQLAction, task: SQLTask) -> SQLReward:
     """
     4-level grader with partial progress signals.
-
     0.99 — exact normalized match
-    0.7 — same tokens, minor whitespace/alias differences
-    0.4 — key SQL keywords all present and correct table/column names
-    0.2 — basic SELECT/FROM structure present
+    0.7  — same tokens, minor whitespace/alias differences
+    0.4  — key SQL keywords all present and correct table/column names
+    0.2  — basic SELECT/FROM structure present
     0.01 — completely wrong
+    All scores are clamped to be strictly between 0.0 and 1.0.
     """
     agent = _normalize(action.corrected_query)
     correct = _normalize(task.canonical_answer)
 
     # ── Level 1: Exact match ─────────────────────────────────
     if agent == correct:
-        return SQLReward(value=0.99, reason="Exact match — perfect correction.")
+        return SQLReward(
+            value=_clamp(0.99),
+            reason="Exact match — perfect correction."
+        )
 
     # ── Level 2: Same token set (right words, minor ordering) ─
     agent_tokens = _tokenize(action.corrected_query)
     correct_tokens = _tokenize(task.canonical_answer)
     if agent_tokens == correct_tokens:
         return SQLReward(
-            value=0.7,
+            value=_clamp(0.7),
             reason="All correct tokens present but structure differs slightly."
         )
 
@@ -60,34 +70,42 @@ def grade(action: SQLAction, task: SQLTask) -> SQLReward:
     correct_kws = _sql_keywords_present(task.canonical_answer)
     agent_kws = _sql_keywords_present(action.corrected_query)
     kw_overlap = len(correct_kws & agent_kws) / max(len(correct_kws), 1)
-
     token_overlap = len(agent_tokens & correct_tokens) / max(len(correct_tokens), 1)
 
     if kw_overlap >= 0.85 and token_overlap >= 0.75:
         return SQLReward(
-            value=0.4,
+            value=_clamp(0.4),
             reason=f"Most keywords correct ({kw_overlap:.0%} keyword match, {token_overlap:.0%} token match)."
         )
 
+    # ── Level 3.5: Partial keyword and structure match ────────
+    if kw_overlap >= 0.7 and token_overlap >= 0.55:
+        return SQLReward(
+            value=_clamp(0.3),
+            reason=f"Partial keyword and structure match ({kw_overlap:.0%} keyword match, {token_overlap:.0%} token match)."
+        )
+
     # ── Level 4: Basic structure present ─────────────────────
     if 'SELECT' in agent and 'FROM' in agent:
         return SQLReward(
-            value=0.2,
+            value=_clamp(0.2),
             reason="Basic SELECT/FROM structure present but significant errors remain."
         )
 
     # ── Level 0: No recognizable SQL ─────────────────────────
-    return SQLReward(value=0.01, reason="Response is not valid SQL.")
+    return SQLReward(value=_clamp(0.01), reason="Response is not valid SQL.")
 
 
 def generate_feedback(action: SQLAction, task: SQLTask, reward: SQLReward) -> str:
     """Human-readable feedback shown in next observation."""
-    if reward.value == 1.0:
+    if reward.value >= 0.99:
         return "Correct! Query matches perfectly."
     if reward.value >= 0.7:
         return "Very close — check spacing or minor clause differences."
     if reward.value >= 0.4:
         return "Good progress — most keywords are right, but check for typos in keywords or column names."
+    if reward.value >= 0.3:
+        return "Partial match — right direction but several keywords or columns are off."
     if reward.value >= 0.2:
         return "Basic structure is there — look carefully at every SQL keyword for typos."
-    return "The response doesn't look like valid SQL. Start with SELECT ... FROM ..."
+    return "The response doesn't look like valid SQL. Start with SELECT ... FROM ..."

sql_env/models.py

@@ -1,6 +1,5 @@
 from pydantic import BaseModel, Field
-from typing import Optional, Any, Dict
-
+from typing import Optional, Any, Dict, Callable
 
 class SQLObservation(BaseModel):
     task_id: str
@@ -11,16 +10,13 @@ class SQLObservation(BaseModel):
     previous_attempt: Optional[str] = None
     feedback: Optional[str] = None
 
-
 class SQLAction(BaseModel):
     corrected_query: str
 
-
 class SQLReward(BaseModel):
-    value: float = Field(ge=0.0, le=1.0)
+    value: float = Field(gt=0.0, lt=1.0)  # strictly between, not ge/le
     reason: str
 
-
 class SQLTask(BaseModel):
     task_id: str
     difficulty: str
@@ -29,10 +25,13 @@ class SQLTask(BaseModel):
     schema_context: Optional[str] = None
     error_hint: Optional[str] = None
     max_steps: int = 5
+    grader: Optional[Callable] = None  # ← add this
 
+    class Config:
+        arbitrary_types_allowed = True  # ← required for Callable in Pydantic
 
 class StepResult(BaseModel):
     observation: SQLObservation
     reward: float
     done: bool
-    info: Dict[str, Any] = Field(default_factory=dict)
+    info: Dict[str, Any] = Field(default_factory=dict)

sql_env/server.py

@@ -1,7 +1,7 @@
 """
 FastAPI HTTP wrapper for SQLCorrectionEnv.
 
-Exposes the OpenEnv-required endpoints: /reset, /step, /state.
+Exposes the OpenEnv-required endpoints: /reset, /step, /state + /tasks for validator.
 """
 
 from contextlib import asynccontextmanager
@@ -12,6 +12,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 
 from sql_env import SQLAction, SQLCorrectionEnv
+from sql_env.tasks import ALL_TASKS
 
 
 class ResetRequest(BaseModel):
@@ -96,21 +97,30 @@ async def health():
     return {"status": "ok", "service": "sql-correction-env"}
 
 
+@app.get("/tasks")
+async def list_tasks():
+    """Return graded tasks by difficulty (RL validator format)."""
+    graded_tasks = {
+        diff: [task.__dict__ for task in tasks if task.grader is not None]
+        for diff, tasks in ALL_TASKS.items()
+    }
+    return graded_tasks  # {"easy": [tasks], "medium": [tasks], "hard": [tasks]}
+
+
 @app.get("/")
 async def root():
     return {
         "name": "SQL Correction RL Environment",
         "version": "1.0.0",
-        "endpoints": ["/reset", "/step", "/state", "/health"],
+        "endpoints": ["/reset", "/step", "/state", "/health", "/tasks"],
         "tasks": ["easy", "medium", "hard"],
     }
 
 
 def main():
     import uvicorn
-
     uvicorn.run(app, host="0.0.0.0", port=7860)
 
 
 if __name__ == "__main__":
-    main()
+    main()

sql_env/tasks/easy.py

@@ -1,4 +1,5 @@
 from sql_env.models import SQLTask
+from sql_env.grader import grade
 
 EASY_TASKS = [
     SQLTask(
@@ -7,6 +8,7 @@ EASY_TASKS = [
         broken_query="SELECT * FORM users WHERE id = 1",
         canonical_answer="SELECT * FROM users WHERE id = 1",
         error_hint="There is a typo in a SQL keyword near the table name.",
+        grader=grade,
     ),
     SQLTask(
         task_id="easy_002",
@@ -14,6 +16,7 @@ EASY_TASKS = [
         broken_query="SELECT name, age FORM employees WHERE department = 'HR'",
         canonical_answer="SELECT name, age FROM employees WHERE department = 'HR'",
         error_hint="There is a typo in a SQL keyword near the table name.",
+        grader=grade,
     ),
     SQLTask(
         task_id="easy_003",
@@ -21,6 +24,7 @@ EASY_TASKS = [
         broken_query="SELECT * FROM products WEHRE price > 100",
         canonical_answer="SELECT * FROM products WHERE price > 100",
         error_hint="There is a typo in the filtering keyword.",
+        grader=grade,
     ),
     SQLTask(
         task_id="easy_004",
@@ -28,6 +32,7 @@ EASY_TASKS = [
         broken_query="SELCT id, name FROM customers",
         canonical_answer="SELECT id, name FROM customers",
         error_hint="There is a typo in the first keyword of the query.",
+        grader=grade,
     ),
     SQLTask(
         task_id="easy_005",
@@ -35,5 +40,6 @@ EASY_TASKS = [
         broken_query="SELECT COUNT(*) FORM orders WHERE status = 'pending'",
         canonical_answer="SELECT COUNT(*) FROM orders WHERE status = 'pending'",
         error_hint="There is a typo in a SQL keyword near the table name.",
+        grader=grade,
     ),
-]
+]

sql_env/tasks/hard.py

@@ -1,4 +1,5 @@
 from sql_env.models import SQLTask
+from sql_env.grader import grade
 
 HARD_TASKS = [
     SQLTask(
@@ -13,6 +14,7 @@ HARD_TASKS = [
         ),
         error_hint=None,
         max_steps=4,
+        grader=grade,
     ),
     SQLTask(
         task_id="hard_002",
@@ -27,6 +29,7 @@ HARD_TASKS = [
         ),
         error_hint=None,
         max_steps=4,
+        grader=grade,
     ),
     SQLTask(
         task_id="hard_003",
@@ -38,5 +41,6 @@ HARD_TASKS = [
         ),
         error_hint=None,
         max_steps=4,
+        grader=grade,
     ),
-]
+]

sql_env/tasks/medium.py

@@ -1,4 +1,5 @@
 from sql_env.models import SQLTask
+from sql_env.grader import grade
 
 MEDIUM_TASKS = [
     SQLTask(
@@ -7,6 +8,7 @@ MEDIUM_TASKS = [
         broken_query="SELECT name, SUM(salary) FORM employees GRUP BY department",
         canonical_answer="SELECT name, SUM(salary) FROM employees GROUP BY department",
         error_hint=None,
+        grader=grade,
     ),
     SQLTask(
         task_id="medium_002",
@@ -14,6 +16,7 @@ MEDIUM_TASKS = [
         broken_query="SELECT * FROM orders WHER total > 500 AND status = 'active' ORDR BY total DESC",
         canonical_answer="SELECT * FROM orders WHERE total > 500 AND status = 'active' ORDER BY total DESC",
         error_hint=None,
+        grader=grade,
     ),
     SQLTask(
         task_id="medium_003",
@@ -21,6 +24,7 @@ MEDIUM_TASKS = [
         broken_query="SELECT department, COUNT(*) AS emp_count FORM employees GROUP BY department HAVNG COUNT(*) > 5",
         canonical_answer="SELECT department, COUNT(*) AS emp_count FROM employees GROUP BY department HAVING COUNT(*) > 5",
         error_hint=None,
+        grader=grade,
     ),
     SQLTask(
         task_id="medium_004",
@@ -28,6 +32,7 @@ MEDIUM_TASKS = [
         broken_query="SELCT product_id, SUM(quantity) FROM sales WEHRE year = 2024 GROUP BY product_id",
         canonical_answer="SELECT product_id, SUM(quantity) FROM sales WHERE year = 2024 GROUP BY product_id",
         error_hint=None,
+        grader=grade,
     ),
     SQLTask(
         task_id="medium_005",
@@ -35,5 +40,6 @@ MEDIUM_TASKS = [
         broken_query="SELECT e.name, d.dept_name FORM employees e INNE JOIN departments d ON e.dept_id = d.id WHER e.salary > 50000",
         canonical_answer="SELECT e.name, d.dept_name FROM employees e INNER JOIN departments d ON e.dept_id = d.id WHERE e.salary > 50000",
         error_hint=None,
+        grader=grade,
     ),
-]
+]