Bhagavan mera madad karo 🙏

backend/main.py

@@ -1,198 +1,171 @@
 import os
 import sys
-import math
 from typing import Any, Dict, List, Optional
 
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from fastapi import FastAPI, Body
+from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+from pydantic import Field
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import (
+    Action as OEAction,
+    Observation as OEObservation,
+    State as OEState,
+    EnvironmentMetadata,
+)
+from openenv.core.env_server.http_server import HTTPEnvServer
 
 from models import (
     Action as ModelAction,
+    Observation as ModelObservation,
     generate_tasks,
     deterministic_grader,
     CLMEnvironment,
 )
 
-_SCORE_MIN = 0.01
-_SCORE_MAX = 0.99
-
-def _safe_score(raw) -> float:
-    if raw is None or (isinstance(raw, float) and math.isnan(raw)):
-        return _SCORE_MIN
-    r = float(raw)
-    return round(max(_SCORE_MIN, min(_SCORE_MAX, r)), 4)
-
-_session: Dict[str, Any] = {
-    "env": None, "task_id": "easy",
-    "done": False, "final_score": _SCORE_MIN, "step_count": 0,
-}
-
-def _run_grader_for_task(task_id: str) -> float:
-    if task_id not in ("easy", "medium", "hard"):
-        task_id = "easy"
-    tasks = generate_tasks(task_id)
-    env = CLMEnvironment(tasks=tasks, max_steps=50)
-    env.reset()
-    for _ in range(50):
-        state = env.state
-        incomplete = [t for t in state.tasks if t.progress < 1.0]
-        if not incomplete:
-            break
-        if state.energy < 0.3 or state.stress > 0.7:
-            action = ModelAction(type="break")
-        else:
-            action = ModelAction(type="work", task_id=incomplete[0].id)
-        _, _, done, _ = env.step(action)
+
+# ── OpenEnv-compatible Action / Observation / State models ──────────────────
+
+class CLMAction(OEAction):
+    """Action for the Cognitive Load Manager environment."""
+    type: str = Field(description="Action type: work, break, switch, or delay")
+    task_id: Optional[str] = Field(default=None, description="Task ID to act on")
+
+    model_config = {"extra": "allow"}
+
+
+class CLMObservation(OEObservation):
+    """Observation from the Cognitive Load Manager environment."""
+    tasks: List[Dict[str, Any]] = Field(default_factory=list)
+    visible_state: Dict[str, Any] = Field(default_factory=dict)
+    time_step: int = Field(default=0)
+
+    model_config = {"extra": "allow"}
+
+
+class CLMState(OEState):
+    """State for the Cognitive Load Manager environment."""
+    energy: float = Field(default=1.0)
+    stress: float = Field(default=0.0)
+    fatigue: float = Field(default=0.0)
+    current_task_id: Optional[str] = Field(default=None)
+    tasks: List[Dict[str, Any]] = Field(default_factory=list)
+
+    model_config = {"extra": "allow"}
+
+
+# ── OpenEnv Environment wrapper ─────────────────────────────────────────────
+
+class CLMEnvWrapper(Environment):
+    """
+    Cognitive Load Manager wrapped as an OpenEnv-compliant environment.
+
+    Three difficulty levels via the task_id reset parameter:
+      - easy:   2 tasks, no deadlines
+      - medium: 5 tasks with deadlines
+      - hard:   8 tasks with tight deadlines
+    """
+
+    SUPPORTS_CONCURRENT_SESSIONS = True
+
+    def __init__(self):
+        super().__init__()
+        level = os.getenv("CLM_LEVEL", "easy")
+        tasks = generate_tasks(level)
+        self._env = CLMEnvironment(tasks=tasks, max_steps=50)
+        self._final_score: float = 0.0
+
+    def _to_oe_obs(self, obs: ModelObservation, done: bool = False, reward: Optional[float] = None, info: Optional[dict] = None) -> CLMObservation:
+        return CLMObservation(
+            tasks=[t.model_dump() for t in obs.tasks],
+            visible_state=obs.visible_state.model_dump(),
+            time_step=obs.time_step,
+            done=done,
+            reward=reward,
+            metadata=info or {},
+        )
+
+    def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None, task_id: str = "easy", **kwargs) -> CLMObservation:
+        if task_id not in ("easy", "medium", "hard"):
+            task_id = "easy"
+        tasks = generate_tasks(task_id)
+        self._env = CLMEnvironment(tasks=tasks, max_steps=50)
+        self._final_score = 0.0
+        obs = self._env.reset()
+        return self._to_oe_obs(obs)
+
+    def step(self, action: CLMAction, timeout_s: Optional[float] = None, **kwargs) -> CLMObservation:
+        model_action = ModelAction(type=action.type, task_id=action.task_id)
+        obs, reward, done, info = self._env.step(model_action)
         if done:
-            break
-    score = deterministic_grader(env.state.tasks, env.state.time_step, env.state.energy)
-    return _safe_score(score)
+            self._final_score = deterministic_grader(
+                self._env.state.tasks,
+                self._env.state.time_step,
+                self._env.state.energy,
+            )
+            info["final_score"] = self._final_score
+        return self._to_oe_obs(obs, done=done, reward=float(reward), info=info)
+
+    @property
+    def state(self) -> CLMState:
+        raw = self._env.state_dict()
+        return CLMState(
+            energy=raw.get("energy", 1.0),
+            stress=raw.get("stress", 0.0),
+            fatigue=raw.get("fatigue", 0.0),
+            current_task_id=raw.get("current_task_id"),
+            tasks=raw.get("tasks", []),
+            step_count=raw.get("time_step", 0),
+        )
+
+    def get_metadata(self) -> EnvironmentMetadata:
+        return EnvironmentMetadata(
+            name="cognitive-load-manager",
+            description=(
+                "Cognitive Load Manager (CLM) simulates human cognitive load "
+                "(energy, stress, fatigue) while managing tasks with deadlines. "
+                "Three difficulty levels: easy (2 tasks, no deadlines), "
+                "medium (5 tasks with deadlines), hard (8 tasks with tight deadlines)."
+            ),
+            version="1.0.0",
+            author="Team Innovators",
+        )
+
+    def close(self) -> None:
+        pass
+
+
+# ── Build FastAPI app via OpenEnv HTTPEnvServer ──────────────────────────────
 
 def build_app() -> FastAPI:
+    server = HTTPEnvServer(
+        env=CLMEnvWrapper,
+        action_cls=CLMAction,
+        observation_cls=CLMObservation,
+        max_concurrent_envs=10,
+    )
+
     _app = FastAPI(
         title="Cognitive Load Manager (CLM) Environment API",
         version="1.0.0",
-        description="OpenEnv-compliant environment for the Meta PyTorch Hackathon.",
+        description=(
+            "OpenEnv-compliant environment for the Meta PyTorch Hackathon. "
+            "Simulates cognitive load management with three difficulty levels."
+        ),
     )
-    _app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
-                        allow_methods=["*"], allow_headers=["*"])
-
-    @_app.get("/")
-    @_app.get("/health")
-    @_app.get("/healthz")
-    async def health():
-        return {"status": "healthy", "name": "cognitive-load-manager", "version": "1.0.0"}
-
-    @_app.get("/metadata")
-    async def metadata():
-        return {
-            "name": "cognitive-load-manager",
-            "description": "Cognitive Load Manager simulates human cognitive load while managing tasks with deadlines.",
-            "version": "1.0.0", "author": "Team Innovators",
-        }
-
-    @_app.get("/schema")
-    async def schema():
-        return {
-            "action": {"type": "object", "properties": {
-                "type": {"type": "string", "enum": ["work", "break", "switch", "delay"]},
-                "task_id": {"type": "string", "nullable": True},
-            }},
-            "observation": {"type": "object", "properties": {
-                "tasks": {"type": "array"},
-                "visible_state": {"type": "object"},
-                "time_step": {"type": "integer"},
-            }},
-            "state": {"type": "object", "properties": {
-                "energy": {"type": "number"}, "stress": {"type": "number"},
-                "fatigue": {"type": "number"}, "time_step": {"type": "integer"},
-            }},
-        }
-
-    @_app.post("/reset")
-    async def reset(body: dict = Body(default={})):
-        task_id = body.get("task_id", "easy")
-        if task_id not in ("easy", "medium", "hard"):
-            task_id = "easy"
-        tasks = generate_tasks(task_id)
-        env = CLMEnvironment(tasks=tasks, max_steps=50)
-        obs = env.reset()
-        _session.update({"env": env, "task_id": task_id, "done": False,
-                         "final_score": _SCORE_MIN, "step_count": 0})
-        return {
-            "observation": {"tasks": [t.model_dump() for t in obs.tasks],
-                            "visible_state": obs.visible_state.model_dump(),
-                            "time_step": obs.time_step},
-            "reward": None, "done": False, "info": {},
-        }
-
-    @_app.post("/step")
-    async def step(body: dict = Body(default={})):
-        env = _session.get("env")
-        if env is None:
-            tasks = generate_tasks("easy")
-            env = CLMEnvironment(tasks=tasks, max_steps=50)
-            env.reset()
-            _session.update({"env": env, "task_id": "easy"})
-
-        raw = body.get("action") or body
-        if isinstance(raw, dict):
-            action_type = raw.get("type", "delay")
-            task_id_action = raw.get("task_id")
-        else:
-            action_type = "delay"
-            task_id_action = None
-        if action_type not in ("work", "break", "switch", "delay"):
-            action_type = "delay"
-
-        action = ModelAction(type=action_type, task_id=task_id_action)
-        obs, raw_reward, done, info = env.step(action)
-        _session["step_count"] = _session.get("step_count", 0) + 1
 
-        if done:
-            final_score = _safe_score(
-                deterministic_grader(env.state.tasks, env.state.time_step, env.state.energy)
-            )
-            _session.update({"done": True, "final_score": final_score})
-            info["final_score"] = final_score
-            reward = final_score
-        else:
-            reward = _safe_score(raw_reward)
-
-        return {
-            "observation": {"tasks": [t.model_dump() for t in obs.tasks],
-                            "visible_state": obs.visible_state.model_dump(),
-                            "time_step": obs.time_step},
-            "reward": reward, "score": reward, "done": done, "info": info,
-        }
-
-    @_app.get("/state")
-    async def state():
-        env = _session.get("env")
-        if env is None:
-            return {"energy": 1.0, "stress": 0.0, "fatigue": 0.0, "time_step": 0, "tasks": []}
-        return env.state_dict()
-
-    @_app.get("/grader")
-    @_app.post("/grader")
-    async def grader_endpoint(body: dict = Body(default={})):
-        env = _session.get("env")
-        if _session.get("done"):
-            score = _session.get("final_score", _SCORE_MIN)
-        elif env is not None:
-            score = _safe_score(
-                deterministic_grader(env.state.tasks, env.state.time_step, env.state.energy)
-            )
-        else:
-            score = _run_grader_for_task(_session.get("task_id", "easy"))
-        return {"task_id": _session.get("task_id", "easy"), "reward": score,
-                "score": score, "done": _session.get("done", False),
-                "step_count": _session.get("step_count", 0)}
-
-    @_app.get("/grade/easy")
-    @_app.get("/grade/t1_easy")
-    async def grade_easy():
-        score = _run_grader_for_task("easy")
-        return {"task_id": "easy", "score": score, "reward": score}
-
-    @_app.get("/grade/medium")
-    @_app.get("/grade/t2_medium")
-    async def grade_medium():
-        score = _run_grader_for_task("medium")
-        return {"task_id": "medium", "score": score, "reward": score}
-
-    @_app.get("/grade/hard")
-    @_app.get("/grade/t3_hard")
-    async def grade_hard():
-        score = _run_grader_for_task("hard")
-        return {"task_id": "hard", "score": score, "reward": score}
-
-    @_app.post("/mcp")
-    async def mcp(body: dict = Body(default={})):
-        return {"jsonrpc": "2.0", "id": body.get("id", 1), "result": {"status": "ok"}}
+    _app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
 
+    server.register_routes(_app)
     return _app
 
+
 app = build_app()

models.py

@@ -68,6 +68,7 @@ def grader(trajectory: dict) -> float:
 
     Wraps deterministic_grader for use with the openenv-core task evaluation
     framework. The trajectory dict should contain keys: tasks, time_step, energy.
+    Score is always strictly in the open interval (0.01, 0.99) — never 0.0 or 1.0.
     """
     raw_tasks = trajectory.get("tasks", [])
     time_step_val = trajectory.get("time_step", 50)
@@ -78,19 +79,21 @@ def grader(trajectory: dict) -> float:
 
 def deterministic_grader(tasks: list[Task], time_step: int, final_energy: float) -> float:
     """
-    A deterministic grader returning a score STRICTLY between 0 and 1 based on:
+    A deterministic grader returning a score strictly in (0.01, 0.99) based on:
     - completion rate
     - deadline adherence
     - energy efficiency
 
-    Score is clamped to [0.01, 0.99] — never exactly 0.0 or 1.0.
+    Score is NEVER exactly 0.0 or 1.0 — always strictly between 0 and 1
+    to satisfy openenv Phase 2 validation requirements.
     """
+    # Guard: no tasks → minimal score (not zero)
     if not tasks:
         return 0.01
 
     completion_rate = sum(t.progress for t in tasks) / len(tasks)
 
-    # penalty for missed deadlines
+    # Penalty for missed deadlines
     missed_deadlines = 0
     for t in tasks:
         if t.deadline and time_step > t.deadline and t.progress < 1.0:
@@ -98,12 +101,13 @@ def deterministic_grader(tasks: list[Task], time_step: int, final_energy: float)
 
     deadline_penalty = min(0.3, missed_deadlines * 0.1)
 
-    # energy efficiency
-    energy_score = max(0.0, (final_energy - 0.1) * 0.2)
+    # Energy efficiency bonus (capped so total can't reach 1.0)
+    energy_score = max(0.0, (final_energy - 0.1) * 0.18)
 
-    score = completion_rate * 0.8 - deadline_penalty + energy_score
-    # Validator requires score strictly in (0, 1) — clamp to [0.01, 0.99]
-    return round(max(0.01, min(0.99, score)), 4)
+    raw = completion_rate * 0.78 - deadline_penalty + energy_score
+
+    # Strictly clamp to open interval (0.01, 0.99) — never 0.0 or 1.0
+    return round(max(0.01, min(0.99, raw)), 4)
 
 
 # ==========================================
@@ -204,7 +208,7 @@ class CLMEnvironment:
                 else:
                     reward += 1.0
                     
-        reward = round(max(0.01, min(0.99, float(reward))), 4)
+        reward = max(0.01, min(0.99, float(reward)))
                     
         return self._get_observation(), reward, done, self.state.model_dump()
         

openenv.yaml

@@ -1,5 +1,5 @@
 spec_version: 1
-name: clm-env
+name: cognitive-load-manager
 type: space
 runtime: fastapi
 app: server.app:app
@@ -8,11 +8,10 @@ description: Cognitive Load Manager (CLM) simulates human cognitive load (energy
 version: "1.0.0"
 
 endpoints:
-  health: /health
+  health: /
   reset:  /reset
   step:   /step
   state:  /state
-  grade:  /grader
 
 schema:
   observation:
@@ -41,26 +40,45 @@ schema:
   reward:
     type: number
 
-scoring:
-  reward_range: [0.01, 0.99]
-  success_threshold: 0.5
-  score_formula: mean(step_rewards)
+graders:
+  deterministic_grader:
+    description: "Evaluates agent performance based on task completion, deadline adherence, and energy efficiency. Score strictly in (0.01, 0.99)."
+    fn: "models.grader"
 
 tasks:
   - id: easy
     difficulty: easy
     description: "2 easy tasks with no deadlines. Agent must complete both tasks without burning out."
     max_steps: 50
-    grader: "models:grader"
+    grader:
+      fn: "models.grader"
+      description: "Score strictly in (0.01, 0.99). Grades on completion rate, deadline adherence, and energy efficiency."
 
   - id: medium
     difficulty: medium
     description: "5 medium tasks with deadlines. Agent must balance speed and energy to meet deadlines."
     max_steps: 50
-    grader: "models:grader"
+    grader:
+      fn: "models.grader"
+      description: "Score strictly in (0.01, 0.99). Grades on completion rate, deadline adherence, and energy efficiency."
 
   - id: hard
     difficulty: hard
     description: "8 hard tasks with tight deadlines and hidden fatigue mechanics. Agent must manage stress and interruptions."
     max_steps: 50
-    grader: "models:grader"
+    grader:
+      fn: "models.grader"
+      description: "Score strictly in (0.01, 0.99). Grades on completion rate, deadline adherence, and energy efficiency."
+
+scoring:
+  reward_range: [0.01, 0.99]
+  success_threshold: 0.5
+  score_formula: deterministic_grader
+  notes: >
+    All task scores are strictly within (0.01, 0.99) — never exactly 0.0 or 1.0.
+    Grader evaluates completion rate, deadline adherence, and energy efficiency.
+
+constraints:
+  max_runtime_seconds: 600
+  max_memory_gb: 4
+  max_vcpu: 2

tasks/__init__.py

@@ -1 +0,0 @@
-# tasks package

tasks/graders.py

@@ -1,158 +0,0 @@
-from typing import Dict, Callable
-
-# ─────────────────────────────────────────────────────────────────────────────
-# GRADER REGISTRY — required by the OpenEnv hackathon validator.
-#
-# Each grader takes (action: str, signals: dict) -> float and must return a
-# score STRICTLY between 0 and 1 (not 0.0, not 1.0).
-#
-# action:  one of "work" | "break" | "switch" | "delay"
-# signals: dict with keys like energy, stress, fatigue, progress, deadline_gap
-# ─────────────────────────────────────────────────────────────────────────────
-
-GRADER_REGISTRY: Dict[str, Callable[[str, dict], float]] = {}
-
-
-def register_grader(task_id: str):
-    def decorator(func: Callable[[str, dict], float]):
-        GRADER_REGISTRY[task_id] = func
-        return func
-    return decorator
-
-
-def _clamp(value: float) -> float:
-    """Clamp to strictly (0, 1) as required by the validator."""
-    return round(min(max(float(value), 0.01), 0.99), 4)
-
-
-def grade_action(task_id: str, action: str, signals: dict) -> float:
-    """
-    Grade a single action for a given task.
-    Falls back to 0.5 if the task has no registered grader.
-    """
-    action = action.lower().strip()
-    if action not in ("work", "break", "switch", "delay"):
-        for a in ("work", "break", "switch", "delay"):
-            if a in action:
-                action = a
-                break
-        else:
-            return 0.05
-
-    grader_func = GRADER_REGISTRY.get(task_id)
-    if not grader_func:
-        return 0.5
-
-    return _clamp(grader_func(action, signals))
-
-
-# ── Task: easy ────────────────────────────────────────────────────────────────
-# 2 tasks, no deadlines. Agent should work efficiently without burning out.
-@register_grader("easy")
-def _grade_easy(action: str, signals: dict) -> float:
-    energy = signals.get("energy", 0.7)
-    progress = signals.get("progress", 0.0)
-    stress = signals.get("stress", 0.0)
-
-    if action == "work":
-        # Working is good when energy is healthy
-        if energy >= 0.4:
-            return _clamp(0.55 + energy * 0.40 + progress * 0.10)
-        else:
-            # Low energy — working now is suboptimal
-            return _clamp(0.20 + energy * 0.25)
-
-    elif action == "break":
-        # Breaks are valuable when energy is low, costly when energy is fine
-        if energy < 0.4:
-            return _clamp(0.70 + (0.4 - energy) * 0.70)
-        else:
-            return _clamp(0.20 + energy * 0.10)
-
-    elif action == "switch":
-        # Unnecessary context-switching in easy mode is mildly penalised
-        return _clamp(0.25 + progress * 0.20)
-
-    else:  # delay
-        return _clamp(0.15 + (1.0 - stress) * 0.15)
-
-
-# ── Task: medium ──────────────────────────────────────────────────────────────
-# 5 medium tasks with moderate deadlines. Agent must balance speed and energy.
-@register_grader("medium")
-def _grade_medium(action: str, signals: dict) -> float:
-    energy = signals.get("energy", 0.7)
-    stress = signals.get("stress", 0.2)
-    deadline_gap = signals.get("deadline_gap", 10)   # steps until nearest deadline
-    progress = signals.get("progress", 0.0)
-
-    urgency = max(0.0, 1.0 - deadline_gap / 20.0)   # 0 = no urgency, 1 = critical
-
-    if action == "work":
-        if energy >= 0.3:
-            return _clamp(0.50 + urgency * 0.35 + energy * 0.20)
-        else:
-            # Working on empty is risky but may be necessary near deadline
-            return _clamp(0.25 + urgency * 0.35)
-
-    elif action == "break":
-        if energy < 0.35 and urgency < 0.6:
-            return _clamp(0.65 + (0.35 - energy) * 0.80)
-        elif urgency >= 0.6:
-            # Break during urgency is a costly choice
-            return _clamp(0.15 + energy * 0.10)
-        else:
-            return _clamp(0.30 + (1.0 - urgency) * 0.25)
-
-    elif action == "switch":
-        # Switching can be okay if current task is blocked / done
-        return _clamp(0.30 + (1.0 - urgency) * 0.20 + progress * 0.15)
-
-    else:  # delay
-        return _clamp(0.12 + (1.0 - urgency) * 0.20)
-
-
-# ── Task: hard ────────────────────────────────────────────────────────────────
-# 8 hard tasks with tight deadlines and hidden fatigue mechanics.
-# Agent must manage stress and avoid interruptions.
-@register_grader("hard")
-def _grade_hard(action: str, signals: dict) -> float:
-    energy = signals.get("energy", 0.6)
-    stress = signals.get("stress", 0.3)
-    deadline_gap = signals.get("deadline_gap", 5)
-    fatigue = signals.get("fatigue", 0.2)
-
-    urgency = max(0.0, 1.0 - deadline_gap / 12.0)
-    overloaded = stress > 0.7 or fatigue > 0.6
-
-    if action == "work":
-        if overloaded:
-            # Grinding while overloaded leads to burnout — penalise
-            return _clamp(0.20 + urgency * 0.25 - stress * 0.10)
-        elif energy >= 0.25:
-            return _clamp(0.52 + urgency * 0.38 + energy * 0.15 - fatigue * 0.10)
-        else:
-            return _clamp(0.18 + urgency * 0.30)
-
-    elif action == "break":
-        if overloaded:
-            return _clamp(0.72 + stress * 0.25)
-        elif energy < 0.3:
-            return _clamp(0.65 + (0.3 - energy) * 0.90)
-        elif urgency > 0.75:
-            return _clamp(0.14 + energy * 0.08)
-        else:
-            return _clamp(0.35 + (1.0 - urgency) * 0.30)
-
-    elif action == "switch":
-        # Switching in hard mode is costly due to context cost
-        if urgency < 0.4 and not overloaded:
-            return _clamp(0.35 + energy * 0.15)
-        else:
-            return _clamp(0.12 + (1.0 - urgency) * 0.12)
-
-    else:  # delay
-        if overloaded and urgency < 0.5:
-            return _clamp(0.55 + stress * 0.25)
-        else:
-            return _clamp(0.10 + (1.0 - urgency) * 0.15)