fix: sync bug fixes (imports, eval safety, missing fields, task guards, rewards)

harfeast_env/client.py

@@ -5,16 +5,10 @@ Connects to HarFeast OpenEnv server via WebSocket/HTTP.
 
 from typing import Any, Dict
 
-try:
-    from openenv.core.client_types import StepResult
-    from openenv.core.env_server.types import State
-    from openenv.core.env_client import EnvClient
-    from harfeast_env.models import HarFeastAction, HarFeastObservation
-except ImportError:
-    from openenv.core.client_types import StepResult
-    from openenv.core.env_server.types import State
-    from openenv.core.env_client import EnvClient
-    from models import HarFeastAction, HarFeastObservation
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+from openenv.core.env_client import EnvClient
+from harfeast_env.models import HarFeastAction, HarFeastObservation
 
 
 class HarFeastEnv(EnvClient[HarFeastAction, HarFeastObservation, State]):

harfeast_env/models.py

@@ -5,10 +5,7 @@ Actions are JSON-serialized calls: {"action": "files.list", "path": "."}
 
 from pydantic import Field
 
-try:
-    from openenv.core.env_server.types import Action, Observation
-except ImportError:
-    from openenv.core.env_server.types import Action, Observation
+from openenv.core.env_server.types import Action, Observation
 
 
 class HarFeastAction(Action):
@@ -46,3 +43,15 @@ class HarFeastObservation(Observation):
         default="[]",
         description="JSON list of filtered dataset names available for chaining",
     )
+    done: bool = Field(
+        default=False,
+        description="Whether the episode has ended",
+    )
+    reward: float = Field(
+        default=0.0,
+        description="Rubric score (0-100) when done, else 0",
+    )
+    metadata: dict = Field(
+        default_factory=dict,
+        description="Extra info (action_taken, last_error, task_id)",
+    )

harfeast_env/server/app.py

@@ -11,14 +11,9 @@ _project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(
 if _project_root not in sys.path:
     sys.path.insert(0, _project_root)
 
-try:
-    from openenv.core.env_server.http_server import create_app
-    from harfeast_env.models import HarFeastAction, HarFeastObservation
-    from harfeast_env.server.harfeast_environment import HarFeastEnvironment
-except ImportError:
-    from openenv.core.env_server.http_server import create_app
-    from models import HarFeastAction, HarFeastObservation
-    from server.harfeast_environment import HarFeastEnvironment
+from openenv.core.env_server.http_server import create_app
+from harfeast_env.models import HarFeastAction, HarFeastObservation
+from harfeast_env.server.harfeast_environment import HarFeastEnvironment
 
 # World path - use env var or default to project harfeast_world
 WORLD_PATH = os.environ.get("HARFEAST_WORLD_PATH") or os.path.join(_project_root, "harfeast_world")

harfeast_env/server/harfeast_environment.py

@@ -7,12 +7,8 @@ import json
 import os
 from uuid import uuid4
 
-try:
-    from openenv.core.env_server.interfaces import Environment
-    from openenv.core.env_server.types import State
-except ImportError:
-    from openenv.core.env_server.interfaces import Environment
-    from openenv.core.env_server.types import State
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
 
 # Import our core logic - use path relative to project root
 import sys

harfeast_openenv/actions.py

@@ -3,6 +3,7 @@
 import ast
 import csv
 import json
+import operator
 import os
 import re
 from collections import defaultdict
@@ -13,6 +14,30 @@ from .schemas import ActionResult
 
 # ── Observation size limits ──────────────────────────────────────
 MAX_TABLE_ROWS = 20
+
+# ── Safe arithmetic evaluator (replaces eval) ────────────────────
+_SAFE_BINOPS = {
+    ast.Add: operator.add, ast.Sub: operator.sub,
+    ast.Mult: operator.mul, ast.Div: operator.truediv,
+}
+
+def _safe_eval_expr(node, namespace=None):
+    """Evaluate an AST node containing only arithmetic on numbers (and optionally named vars)."""
+    if isinstance(node, ast.Expression):
+        return _safe_eval_expr(node.body, namespace)
+    if isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
+        return node.value
+    if isinstance(node, ast.BinOp) and type(node.op) in _SAFE_BINOPS:
+        left = _safe_eval_expr(node.left, namespace)
+        right = _safe_eval_expr(node.right, namespace)
+        return _SAFE_BINOPS[type(node.op)](left, right)
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub):
+        return -_safe_eval_expr(node.operand, namespace)
+    if isinstance(node, ast.Name) and namespace is not None:
+        if node.id in namespace:
+            return namespace[node.id]
+        raise ValueError(f"Unknown variable: {node.id}")
+    raise ValueError(f"Unsupported expression element: {ast.dump(node)}")
 MAX_DOCUMENT_CHARS = 2000
 def handle_files_list(world_path: str, path: str = ".") -> ActionResult:
     """
@@ -412,7 +437,7 @@ def handle_data_add_columns(
                 v = _try_float(row.get(c, ""))
                 ns[c] = v if isinstance(v, (int, float)) else 0
             try:
-                row[new_column] = round(eval(expression, {"__builtins__": {}}, ns), 2)
+                row[new_column] = round(_safe_eval_expr(tree, namespace=ns), 2)
             except Exception:
                 row[new_column] = 0
             new_rows.append(row)
@@ -442,7 +467,8 @@ def handle_data_compute(expression: str) -> ActionResult:
             error="Invalid expression",
         )
     try:
-        result = eval(expr)
+        tree = ast.parse(expr, mode="eval")
+        result = _safe_eval_expr(tree)
         if isinstance(result, float) and not result.is_integer():
             return ActionResult(observation=str(round(result, 2)))
         return ActionResult(observation=str(result))

harfeast_openenv/environment.py

@@ -127,6 +127,15 @@ class HarFeastOpenEnv:
         Execute one action and return the result.
         Action format: {"action": "files.list", "path": "."} or JSON string.
         """
+        if self._task is None:
+            return StepResult(
+                observation="No task loaded. Call reset() before step().",
+                prompt="",
+                step_count=0,
+                done=True,
+                reward=0.0,
+                info={"action_taken": "none", "last_error": "reset() not called"},
+            )
         if self._done:
             return StepResult(
                 observation="Episode already ended. Call reset() to start a new episode.",
@@ -286,7 +295,7 @@ class HarFeastOpenEnv:
 
     def _build_context_summary(self) -> str:
         """Compact summary of the episode so far, prepended to every observation."""
-        if not self._history:
+        if not self._history or not self._task:
             return ""
 
         lines = [f"=== Task: {self._task['task_name']} ==="]

harfeast_openenv/rewards.py

@@ -0,0 +1,102 @@
+"""
+GDPO-style decomposed reward functions for HarFeast GRPO training.
+
+Three independent reward signals, each normalized independently by TRL's
+GRPOTrainer when passed as a list to reward_funcs. This is equivalent to
+NVIDIA's GDPO (Jan 2026) multi-signal normalization.
+
+Signature: reward_func(completions: list[list[dict]], **kwargs) -> list[float]
+  - completions[i] = [{"role": "assistant", "content": "..."}]
+  - kwargs include dataset columns: "rubric" (JSON-serialized list of criteria)
+"""
+
+import json
+import re
+from .rubric import score_answer
+
+
+def _extract_text(completions):
+    """Extract plain text from TRL chat-format completions."""
+    texts = []
+    for comp in completions:
+        if isinstance(comp, list) and comp:
+            texts.append(comp[-1].get("content", ""))
+        elif isinstance(comp, str):
+            texts.append(comp)
+        else:
+            texts.append("")
+    return texts
+
+
+def _extract_answer(text):
+    """Pull the answer portion after 'Answer:' if present."""
+    if "Answer:" in text:
+        return text.split("Answer:")[-1].strip()
+    return text.strip()
+
+
+def reward_correctness(completions, **kwargs):
+    """
+    Signal 1: Rubric correctness (0.0 - 1.0).
+    Scores each completion against task rubric criteria using deterministic
+    substring matching. This is the primary learning signal.
+    """
+    texts = _extract_text(completions)
+    rubric_strs = kwargs.get("rubric", [])
+    rewards = []
+    for i, text in enumerate(texts):
+        answer = _extract_answer(text)
+        try:
+            rubric = json.loads(rubric_strs[i]) if i < len(rubric_strs) else []
+        except (json.JSONDecodeError, TypeError):
+            rubric = []
+        if not rubric:
+            rewards.append(0.0)
+            continue
+        score, _ = score_answer(answer, rubric)
+        rewards.append(score / 100.0)
+    return rewards
+
+
+def reward_format(completions, **kwargs):
+    """
+    Signal 2: Format compliance (0.0 or 1.0).
+    Checks that the completion follows the expected output structure:
+    contains 'Answer:', includes at least one number, reasonable length.
+    """
+    texts = _extract_text(completions)
+    rewards = []
+    for text in texts:
+        score = 0.0
+        has_answer_prefix = "Answer:" in text or "answer:" in text.lower()
+        has_number = bool(re.search(r"\d+\.?\d*", text))
+        reasonable_length = 50 <= len(text) <= 3000
+        if has_answer_prefix and has_number and reasonable_length:
+            score = 1.0
+        elif has_number and reasonable_length:
+            score = 0.5
+        rewards.append(score)
+    return rewards
+
+
+def reward_completeness(completions, **kwargs):
+    """
+    Signal 3: Numeric completeness (0.0 - 1.0).
+    Measures how many distinct numeric values appear in the answer relative
+    to the number of rubric criteria. Rewards specificity: an answer with
+    concrete numbers for every criterion scores higher.
+    """
+    texts = _extract_text(completions)
+    rubric_strs = kwargs.get("rubric", [])
+    rewards = []
+    for i, text in enumerate(texts):
+        answer = _extract_answer(text)
+        try:
+            rubric = json.loads(rubric_strs[i]) if i < len(rubric_strs) else []
+        except (json.JSONDecodeError, TypeError):
+            rubric = []
+        n_criteria = max(len(rubric), 1)
+        numbers = set(re.findall(r"\b\d[\d,.]*\d\b|\b\d+\b", answer))
+        ratio = min(len(numbers) / n_criteria, 1.0)
+        rewards.append(round(ratio, 3))
+    return rewards