Infrance script fixed

inference.py

@@ -0,0 +1,618 @@
+"""
+Inference script for OpenEnv Store environment.
+
+Uses an LLM (via OpenAI-compatible client) to play the kirana-store simulation.
+Emits structured [START], [STEP], [END] logs for evaluation scoring.
+
+Required env vars:
+    API_BASE_URL  – LLM API endpoint
+    MODEL_NAME    – model identifier
+    HF_TOKEN      – API key
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+from dotenv import load_dotenv
+
+load_dotenv(Path(__file__).resolve().parent / ".env")
+
+from openai import AsyncOpenAI
+
+from client import StoreEnv
+from models import (
+    OrderRequest,
+    PriceUpdate,
+    StoreAction,
+    StoreObservation,
+    dump_model,
+)
+
+API_BASE_URL = os.environ["API_BASE_URL"]
+MODEL_NAME = os.environ["MODEL_NAME"]
+HF_TOKEN = os.environ["HF_TOKEN"]
+
+BENCHMARK = "store"
+MAX_STEPS = 10
+MAX_TOTAL_REWARD = MAX_STEPS * 1.0
+SUCCESS_SCORE_THRESHOLD = 0.5
+
+TASKS: list[dict[str, Any]] = [
+    {
+        "name": "margin_aware_pricing",
+        "description": (
+            "Optimize selling prices using the ground-truth selling score formula: "
+            "selling_score = max(0, demand_score - margin_pct * 3). "
+            "The agent must identify which thin-margin SKUs (Milk, Bread, Eggs, "
+            "Bottled Water) are anchor items driving volume through high selling scores, "
+            "and resist the naive urge to raise every low-margin price. Meanwhile, "
+            "it should find genuinely over-margined or low-demand products where a "
+            "price cut boosts volume, or under-margined items where a raise barely "
+            "hurts score. Sugar is the key trap: thin margin but strong anchor role."
+        ),
+        "max_steps": MAX_STEPS,
+        "success_threshold": 0.5,
+    },
+    {
+        "name": "supplier_risk_arbitrage",
+        "description": (
+            "Navigate the seller reliability spectrum to restock fast-movers cheaply "
+            "without incurring late-delivery stockouts. Seller A offers Rice at 138, "
+            "Oil at 156, Spices at 345 — far below Seller B — but overcommits and "
+            "frequently delivers 1-2 days late. Seller C quotes conservatively on "
+            "Bread (31), Eggs (64), Curd (33), Vegetables (38) and often arrives "
+            "early. The agent must weigh price savings against delivery risk, use "
+            "Seller B as a reliable baseline, and avoid staking urgent restocks on "
+            "Seller A when stock cover is already thin (Biscuits at 40, Water at 48)."
+        ),
+        "max_steps": MAX_STEPS,
+        "success_threshold": 0.5,
+    },
+    {
+        "name": "inventory_and_capital_discipline",
+        "description": (
+            "Maintain service levels on high-demand fast-movers while avoiding "
+            "capital sinks. Starting cash is only ₹100k against ~₹240k inventory. "
+            "Kitchen Appliances (demand 28, buy 1800, qty 4 = ₹7200 locked) is "
+            "dead stock the agent should stop restocking. Biscuits (demand 90, qty 40) "
+            "and Bottled Water (demand 89, qty 48) are replenishment misses that need "
+            "immediate reorder. The agent must balance reorder urgency against cash "
+            "preservation — daily expenses are ₹3000, and bank balance going negative "
+            "ends the episode. Reward = 0.5 + (capital_change - recurring_costs) / "
+            "starting_capital, so wasted capital directly reduces the score."
+        ),
+        "max_steps": MAX_STEPS,
+        "success_threshold": 0.5,
+    },
+    {
+        "name": "marketing_roi_evaluation",
+        "description": (
+            "Select durable marketing actions that maximize order-processing capacity "
+            "and satisfaction per rupee of recurring cost. Cheap, effective picks: "
+            "Shelf placement (ID 1: ₹800 one-time, 0 recurring, +20 capacity), "
+            "WhatsApp ordering (ID 4: ₹1500, ₹100/day, +15 capacity), Staff training "
+            "(ID 10: ₹2500, 0 recurring, +25 capacity). Mid-game path: Local delivery "
+            "(ID 7), Website (ID 12), Rider (ID 13), Stockroom (ID 14). The trap is "
+            "Action 15 (social ads): ₹4000 upfront, ₹1200/day recurring, +0 capacity "
+            "— a weak-ROI money drain. The aspirational Action 11 (second branch: "
+            "₹750k) is unreachable on day-1 capital. The agent should evaluate total "
+            "cost of ownership, not just headline satisfaction boosts."
+        ),
+        "max_steps": MAX_STEPS,
+        "success_threshold": 0.45,
+    },
+    {
+        "name": "full_store_management",
+        "description": (
+            "Holistic 30-day store management combining all dimensions: pricing using "
+            "the selling-score formula, supplier selection balancing cost vs reliability, "
+            "inventory discipline on fast-movers and dead stock, and phased marketing "
+            "investments. The agent must sequence decisions across 10 three-day windows, "
+            "adapt to delivery arrivals and changing stock levels, and avoid both "
+            "bankruptcy (bank < 0) and stagnation (no growth). This is the integrative "
+            "test: partial credit for getting any single dimension right, full credit "
+            "for coherent multi-objective reasoning across the entire episode."
+        ),
+        "max_steps": MAX_STEPS,
+        "success_threshold": 0.5,
+    },
+]
+
+ENV_URL = os.environ.get("ENV_URL", "http://localhost:8000")
+
+
+def log_start(*, task: str, env: str, model: str) -> None:
+    print(
+        json.dumps(
+            {"type": "START", "task": task, "env": env, "model": model},
+            separators=(",", ":"),
+        ),
+        flush=True,
+    )
+
+
+def log_step(
+    *,
+    step: int,
+    action: dict[str, Any] | str,
+    reward: float,
+    done: bool,
+    error: str | None,
+) -> None:
+    print(
+        json.dumps(
+            {
+                "type": "STEP",
+                "step": step,
+                "action": action,
+                "reward": reward,
+                "done": done,
+                "error": error,
+            },
+            separators=(",", ":"),
+        ),
+        flush=True,
+    )
+
+
+def log_end(
+    *,
+    success: bool,
+    steps: int,
+    score: float,
+    rewards: list[float],
+) -> None:
+    print(
+        json.dumps(
+            {
+                "type": "END",
+                "success": success,
+                "steps": steps,
+                "score": score,
+                "rewards": rewards,
+            },
+            separators=(",", ":"),
+        ),
+        flush=True,
+    )
+
+
+def _format_observation(obs: StoreObservation) -> str:
+    """Build a concise text summary of the observation for the LLM prompt."""
+    store = obs.store
+    lines = [
+        "=== Store Snapshot ===",
+        f"Day: {store.day}/{store.episode_horizon_days}",
+        f"Bank Balance: ₹{store.bank_balance_inr:,.2f}",
+        f"Customer Satisfaction: {store.customer_satisfaction}",
+        f"Order Processing Capacity: {store.order_processing_capacity}",
+        f"Daily Expense: ₹{store.current_daily_expense_inr:,.2f}",
+        f"Cumulative Profit: ₹{store.cumulative_profit_inr:,.2f}",
+        f"Active Recurring Cost: ₹{store.active_recurring_cost_inr:,.2f}",
+        f"Active Action IDs: {store.active_action_ids}",
+        "",
+        "=== Current Stock (top items by value) ===",
+    ]
+    sorted_stock = sorted(obs.stock, key=lambda s: s.stock_value_inr, reverse=True)
+    for item in sorted_stock[:15]:
+        margin = (
+            ((item.selling_price_inr - item.buying_price_inr) / item.selling_price_inr) * 100
+            if item.selling_price_inr > 0
+            else 0
+        )
+        lines.append(
+            f"  {item.product_name}: qty={item.quantity_on_hand:.1f}, "
+            f"buy=₹{item.buying_price_inr}, sell=₹{item.selling_price_inr}, "
+            f"demand={item.demand_score}, margin={margin:.1f}%, "
+            f"value=₹{item.stock_value_inr:.0f}"
+        )
+
+    low_stock = [s for s in obs.stock if 0 < s.quantity_on_hand < 15]
+    if low_stock:
+        lines.append("")
+        lines.append("=== Low Stock Alert ===")
+        for item in low_stock:
+            lines.append(f"  {item.product_name}: qty={item.quantity_on_hand:.1f}")
+
+    if obs.pending_orders:
+        lines.append("")
+        lines.append("=== Pending Orders ===")
+        for po in obs.pending_orders:
+            lines.append(
+                f"  {po.order_id}: {po.product_name} x{po.quantity} from {po.seller_name}, "
+                f"arrives in {po.days_remaining}d"
+            )
+
+    lines.append("")
+    lines.append("=== Marketing Actions (inactive only) ===")
+    for ma in obs.marketing_actions:
+        if not ma.is_active:
+            lines.append(
+                f"  ID {ma.action_id}: {ma.description} | "
+                f"cost=₹{ma.cost_inr}, recurring=₹{ma.recurring_cost_inr}/day, "
+                f"satisfaction_delta={ma.customer_satisfaction_delta:+d}, "
+                f"capacity_delta={ma.order_processing_capacity_delta:+d}"
+            )
+
+    if obs.metadata:
+        rb = obs.metadata.get("reward_breakdown")
+        if rb:
+            lines.append("")
+            lines.append("=== Last Reward Breakdown ===")
+            lines.append(f"  Starting Capital: ₹{rb.get('starting_capital_inr', 'N/A')}")
+            lines.append(f"  Ending Capital: ₹{rb.get('ending_capital_inr', 'N/A')}")
+            lines.append(f"  Difference: ₹{rb.get('difference_inr', 'N/A')}")
+            lines.append(f"  Recurring Costs: ₹{rb.get('recurring_costs_paid_inr', 'N/A')}")
+
+    return "\n".join(lines)
+
+
+SYSTEM_PROMPT = """\
+You are a store management AI agent controlling a neighborhood kirana (grocery) store in India.
+
+## Simulation Mechanics
+
+Each step you submit ONE bundled action for the next 3-day decision window:
+1. orders: list of supplier orders [{"product": "...", "seller": "Seller X", "quantity": N}]
+2. prices: list of price updates [{"product": "...", "price": N}] (in-stock products only)
+3. action_ids: list of marketing/operational action IDs to activate
+
+## Ground-Truth Formulas
+
+DAILY ORDERS PROCESSED = order_processing_capacity × (customer_satisfaction / 100)
+
+For each in-stock product with quantity > 0:
+  margin_pct = ((selling_price - buying_price) / selling_price) × 100
+  product_selling_score = max(0, demand_score - margin_pct × 3)
+
+TOTAL_SELLING_SCORE = sum of all product_selling_scores
+Each product's daily sales = (product_selling_score / TOTAL_SELLING_SCORE) × DAILY_ORDERS_PROCESSED
+  (capped at available quantity)
+
+REWARD = 0.5 + (ending_capital - starting_capital - recurring_costs_6days) / starting_capital
+  where capital = bank_balance + total_inventory_value
+
+CUSTOMER SATISFACTION UPDATE after price/stock changes:
+  new_satisfaction = (1 + (score_after - score_before) / score_after) × base_satisfaction
+  Capped at [1, 100].
+
+## Seller Profiles
+- Seller A: Cheapest on staples but OVERCOMMITS — deliveries often 1-2 days late
+- Seller B: Reliable baseline, matches quoted ETA consistently
+- Seller C: Quotes conservatively, often arrives EARLY — best for urgent fresh restocks
+- Seller D: Competitive on snacks/beverages but execution is uneven
+
+## Key Constraints
+- Episode: 30 days, each step commits 3 days, reward horizon = 6 days
+- Bank balance < 0 → episode ends immediately
+- Marketing actions are DURABLE: one-time cost + permanent recurring daily cost
+- Starting cash is tight (₹100k) relative to inventory (~₹240k)
+
+## Response Format
+You MUST respond with ONLY valid JSON:
+{
+  "reasoning": "brief explanation of your decision",
+  "orders": [{"product": "...", "seller": "Seller X", "quantity": N}, ...],
+  "prices": [{"product": "...", "price": N}, ...],
+  "action_ids": [N, ...]
+}
+No extra text outside JSON. Product names must exactly match the catalog.
+"""
+
+
+def _build_task_system_prompt(task: dict[str, Any]) -> str:
+    task_goal = {
+        "margin_aware_pricing": (
+            "## Task: Margin-Aware Pricing\n\n"
+            "Your PRIMARY goal is to optimize selling prices using the selling-score formula.\n\n"
+            "The formula selling_score = max(0, demand - margin% × 3) means:\n"
+            "- A product with demand 96 and margin 6% has score = 96 - 18 = 78 (strong seller)\n"
+            "- Raising that margin to 20% gives score = 96 - 60 = 36 (volume collapses)\n"
+            "- A product with demand 28 at any margin has negligible score anyway\n\n"
+            "KEY INSIGHT: Thin-margin anchor items (Milk, Bread, Eggs, Bottled Water) have "
+            "HIGH selling scores because margin% × 3 is small. Raising their price destroys "
+            "volume disproportionately. Sugar (demand 74, margin ~5%) is a deliberate anchor — "
+            "do NOT raise it aggressively.\n\n"
+            "WHAT TO DO:\n"
+            "- Calculate selling_score for every in-stock product before changing prices\n"
+            "- Only raise prices on items where demand is high enough to absorb the score loss\n"
+            "- Consider cutting prices on over-margined items (Coffee: ~22% margin, demand 62)\n"
+            "- Kitchen Appliances (demand 28, margin ~35%) sell almost nothing — pricing won't help\n"
+            "- Protect total_selling_score: it directly feeds daily order allocation"
+        ),
+        "supplier_risk_arbitrage": (
+            "## Task: Supplier Risk Arbitrage\n\n"
+            "Your PRIMARY goal is to restock fast-movers at lowest cost without stockouts.\n\n"
+            "SELLER BEHAVIOR (actual delivery = quoted_ETA + random offset):\n"
+            "- Seller A: offset from {0,+1,+2} with weights {2,4,5} — most likely +2 days late\n"
+            "- Seller B: offset = 0 always — perfectly reliable\n"
+            "- Seller C: offset from {-2,-1,0} with weights {5,4,2} — most likely 2 days early\n"
+            "- Seller D: offset from {-1,0,+1,+2} with weights {2,4,3,2} — unpredictable\n\n"
+            "KEY OPPORTUNITIES:\n"
+            "- Seller A: Rice 138 (vs B: 160), Oil 156 (vs B: 180), Spices 345 (vs B: 400)\n"
+            "  → Big savings but expect delivery 3-4 days instead of quoted 2\n"
+            "- Seller C: Bread 31, Eggs 64, Curd 33, Vegetables 38 — arrives 3 days early\n"
+            "  → Best for urgent perishable restocks despite higher quoted ETA\n\n"
+            "URGENT RESTOCKS NEEDED:\n"
+            "- Biscuits: qty 40, demand 90 — will sell out fast, reorder via Seller B or C\n"
+            "- Bottled Water: qty 48, demand 89 — thin cover, needs immediate replenishment\n\n"
+            "STRATEGY: Use Seller A for non-urgent bulk staples (Rice, Oil) where you can "
+            "absorb delivery slippage. Use Seller C for urgent perishable/fresh restocks. "
+            "Use Seller B as the safe default when timing matters."
+        ),
+        "inventory_and_capital_discipline": (
+            "## Task: Inventory & Capital Discipline\n\n"
+            "Your PRIMARY goal is to protect service levels on fast-movers while preserving capital.\n\n"
+            "STARTING POSITION:\n"
+            "- Bank: ₹100,000 | Inventory: ~₹240,000 | Daily expense: ₹3,000\n"
+            "- Only ~33 days of cash runway before expenses alone drain the bank\n"
+            "- Revenue from sales replenishes cash, but you must keep selling\n\n"
+            "DEAD STOCK TO AVOID:\n"
+            "- Kitchen Appliances: demand 28, buy ₹1800, qty 4 = ₹7,200 locked capital\n"
+            "  Selling score ≈ max(0, 28 - 35%×3) ≈ 0 — these barely move. NEVER reorder.\n\n"
+            "REPLENISHMENT PRIORITIES (by demand × low stock):\n"
+            "- Biscuits: demand 90, qty 40, buy ₹20 → cheap to restock, huge demand\n"
+            "- Bottled Water: demand 89, qty 48, buy ₹18 → cheap and high demand\n"
+            "- Eggs: demand 84, qty 24 → running low\n"
+            "- Bread: demand 86, qty 36 → perishable, needs frequent restocking\n\n"
+            "CAPITAL MATH: Each order is paid upfront on ordering (bank -= buy_price × qty). "
+            "Revenue flows in daily from sales. Over-ordering locks capital in inventory "
+            "that may not sell fast enough, starving you of cash for expenses.\n\n"
+            "RULE: Keep bank_balance > ₹20k safety buffer at all times. Order in small "
+            "batches rather than bulk. Prioritize items with highest demand-to-cost ratio."
+        ),
+        "marketing_roi_evaluation": (
+            "## Task: Marketing ROI Evaluation\n\n"
+            "Your PRIMARY goal is to select marketing actions that maximize capacity and "
+            "satisfaction per rupee of TOTAL cost (upfront + recurring over remaining days).\n\n"
+            "ZERO-RECURRING QUICK WINS (activate early):\n"
+            "- ID 1: Shelf placement — ₹800, +20 capacity, +1 satisfaction, 0 recurring\n"
+            "- ID 6: Storage racks — ₹7,000, +30 capacity, 0 satisfaction, 0 recurring\n"
+            "- ID 10: Staff training — ₹2,500, +25 capacity, +2 satisfaction, 0 recurring\n"
+            "- ID 9: Clearance shelf — ₹500, +6 capacity, -2 satisfaction, 0 recurring\n\n"
+            "MODERATE-RECURRING GOOD VALUE:\n"
+            "- ID 4: WhatsApp ordering — ₹1,500 + ₹100/day, +15 capacity, +4 satisfaction\n"
+            "- ID 8: Referral rewards — ₹1,800 + ₹150/day, 0 capacity, +3 satisfaction\n\n"
+            "MID-GAME EXPANSION (expensive but transformative if cash allows):\n"
+            "- ID 7: Delivery partner — ₹5,000 + ₹600/day, +40 capacity\n"
+            "- ID 12: Website — ₹60,000 + ₹400/day, +60 capacity\n"
+            "- ID 13: Delivery rider — ₹45,000 + ₹900/day, +50 capacity\n\n"
+            "THE TRAP — DO NOT ACTIVATE:\n"
+            "- ID 15: Social ads — ₹4,000 + ₹1,200/day, +0 capacity, only +3 satisfaction\n"
+            "  → Over 30 days this costs ₹40,000 total with ZERO capacity gain\n\n"
+            "UNREACHABLE:\n"
+            "- ID 11: Second branch — ₹750,000 upfront. You only have ₹100k. Skip it.\n\n"
+            "FORMULA IMPACT: More capacity → more daily_orders_processed → more revenue. "
+            "Recurring costs are subtracted from reward. Evaluate 6-day total cost of "
+            "ownership against the capacity gain."
+        ),
+        "full_store_management": (
+            "## Task: Full Store Management (Integrative)\n\n"
+            "Your PRIMARY goal is to run the store profitably across all 10 decision windows "
+            "by combining pricing, ordering, inventory management, and marketing.\n\n"
+            "PHASE 1 (Steps 1-3): Foundation\n"
+            "- Activate zero-recurring marketing: IDs 1, 10, 6 (total ₹10,300, +75 capacity)\n"
+            "- Restock urgent items: Biscuits and Bottled Water via Seller B or C\n"
+            "- Review prices: do NOT raise Milk/Bread/Eggs/Sugar — they're anchor items\n"
+            "- Consider cutting Coffee price to boost its selling score\n\n"
+            "PHASE 2 (Steps 4-6): Growth\n"
+            "- Activate WhatsApp ordering (ID 4) for +15 capacity at ₹100/day\n"
+            "- Use Seller A for bulk Rice/Oil/Spices — savings are ~15-20% vs Seller B\n"
+            "- Monitor delivery arrivals and restock perishables via Seller C as needed\n"
+            "- Evaluate delivery partner (ID 7) — +40 capacity but ₹600/day\n\n"
+            "PHASE 3 (Steps 7-10): Optimization\n"
+            "- Fine-tune prices based on observed stock depletion rates\n"
+            "- If profitable, invest in ID 12 (website) or ID 13 (rider) for big capacity\n"
+            "- NEVER activate ID 15 (social ads) — ₹1,200/day for +0 capacity is a trap\n"
+            "- NEVER reorder Kitchen Appliances — dead stock\n"
+            "- Keep bank > ₹15k at all times to avoid bankruptcy\n\n"
+            "REWARD OPTIMIZATION: Each step's reward = 0.5 + capital_growth_rate. "
+            "Capital = bank + inventory. Maximize revenue through high selling scores, "
+            "minimize costs through smart supplier selection and avoiding wasteful marketing."
+        ),
+    }
+    goal = task_goal.get(task["name"], "Maximize your score.")
+    return SYSTEM_PROMPT + f"\n\n{goal}"
+
+
+async def get_model_action(
+    client: AsyncOpenAI,
+    step: int,
+    observation_text: str,
+    last_reward: float,
+    history: list[str],
+    task_system_prompt: str,
+) -> dict[str, Any]:
+    """Query the LLM for the next action."""
+    history_text = "\n".join(history[-5:]) if history else "No history yet."
+
+    user_msg = (
+        f"Step {step} | Last reward: {last_reward:+.4f}\n\n"
+        f"Recent history:\n{history_text}\n\n"
+        f"Current observation:\n{observation_text}\n\n"
+        "Decide your next action. Respond with ONLY valid JSON."
+    )
+
+    response = await client.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": task_system_prompt},
+            {"role": "user", "content": user_msg},
+        ],
+        temperature=0.3,
+        max_tokens=1024,
+    )
+
+    content = response.choices[0].message.content or "{}"
+    content = content.strip()
+    if content.startswith("```"):
+        content = content.split("\n", 1)[-1]
+        if content.endswith("```"):
+            content = content[: -len("```")]
+        content = content.strip()
+
+    return json.loads(content)
+
+
+def _parse_action(raw: dict[str, Any]) -> StoreAction:
+    """Convert the LLM JSON response into a StoreAction."""
+    orders = [
+        OrderRequest(
+            product=o["product"],
+            seller=o["seller"],
+            quantity=int(o["quantity"]),
+        )
+        for o in raw.get("orders", [])
+    ]
+    prices = [
+        PriceUpdate(product=p["product"], price=int(p["price"]))
+        for p in raw.get("prices", [])
+    ] or None
+    action_ids = [int(a) for a in raw.get("action_ids", [])]
+    return StoreAction(orders=orders, prices=prices, action_ids=action_ids)
+
+
+async def run_task(
+    llm_client: AsyncOpenAI,
+    task: dict[str, Any],
+) -> float:
+    """Run a single task episode and return the clamped score."""
+    task_name = task["name"]
+    max_steps = task["max_steps"]
+    threshold = task["success_threshold"]
+    task_system_prompt = _build_task_system_prompt(task)
+
+    history: list[str] = []
+    rewards: list[float] = []
+    steps_taken = 0
+    score = 0.0
+    success = False
+
+    log_start(task=task_name, env=BENCHMARK, model=MODEL_NAME)
+
+    env = StoreEnv(base_url=ENV_URL)
+
+    try:
+        result = await env.reset()
+        obs = result.observation
+        obs_text = _format_observation(obs)
+        last_reward = 0.0
+
+        for step in range(1, max_steps + 1):
+            if obs.done:
+                break
+
+            raw_action: dict[str, Any] = {}
+            action_str = ""
+            error = None
+
+            try:
+                raw_action = await get_model_action(
+                    llm_client,
+                    step,
+                    obs_text,
+                    last_reward,
+                    history,
+                    task_system_prompt,
+                )
+                action = _parse_action(raw_action)
+                action_str = json.dumps(dump_model(action, exclude_none=True), separators=(",", ":"))
+            except Exception as e:
+                print(f"[DEBUG] Action parse error at step {step}: {e}", flush=True)
+                action = StoreAction()
+                action_str = "{}"
+                error = str(e)
+
+            try:
+                result = await env.step(action)
+            except Exception as e:
+                print(f"[DEBUG] Step error at step {step}: {e}", flush=True)
+                action = StoreAction()
+                action_str = "{}"
+                error = str(e)
+                try:
+                    result = await env.step(action)
+                except Exception as e2:
+                    print(f"[DEBUG] Pass-step also failed: {e2}", flush=True)
+                    error = str(e2)
+                    break
+
+            obs = result.observation
+            reward = result.reward or 0.0
+            done = result.done
+
+            rewards.append(reward)
+            steps_taken = step
+            obs_text = _format_observation(obs)
+            last_reward = reward
+
+            log_step(
+                step=step,
+                action=action_str,
+                reward=reward,
+                done=done,
+                error=error,
+            )
+
+            reasoning = raw_action.get("reasoning", "")
+            history.append(
+                f"Step {step}: reward={reward:+.4f}, done={done}, "
+                f"reasoning={reasoning!r}"
+            )
+
+            if done:
+                break
+
+        score = sum(rewards) / (max_steps * 1.0) if max_steps > 0 else 0.0
+        score = min(max(score, 0.0), 1.0)
+        success = score >= threshold
+
+    finally:
+        try:
+            await env.close()
+        except Exception as e:
+            print(f"[DEBUG] env.close() error (container cleanup): {e}", flush=True)
+        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+    return score
+
+
+async def main() -> None:
+    llm_client = AsyncOpenAI(
+        base_url=API_BASE_URL,
+        api_key=HF_TOKEN,
+    )
+
+    print(f"[DEBUG] Starting inference with model={MODEL_NAME}", flush=True)
+    print(f"[DEBUG] API_BASE_URL={API_BASE_URL}", flush=True)
+    print(f"[DEBUG] ENV_URL={ENV_URL}", flush=True)
+    print(f"[DEBUG] Tasks: {[t['name'] for t in TASKS]}", flush=True)
+
+    all_scores: list[float] = []
+
+    for task in TASKS:
+        print(f"\n[DEBUG] === Running task: {task['name']} ===", flush=True)
+        t0 = time.time()
+        task_score = await run_task(llm_client, task)
+        elapsed = time.time() - t0
+        all_scores.append(task_score)
+        print(
+            f"[DEBUG] Task {task['name']} completed: score={task_score:.4f}, "
+            f"elapsed={elapsed:.1f}s",
+            flush=True,
+        )
+
+    avg_score = sum(all_scores) / len(all_scores) if all_scores else 0.0
+    print(f"\n[DEBUG] All task scores: {all_scores}", flush=True)
+    print(f"[DEBUG] Average score: {avg_score:.4f}", flush=True)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

pyproject.toml

@@ -14,20 +14,12 @@ version = "0.1.0"
 description = "Store environment for OpenEnv"
 requires-python = ">=3.10"
 dependencies = [
-    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
-    # install from github
-    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    # Core OpenEnV runtime (provides FastAPI server + HTTP client types)
     "gradio>=6.0.0",
     "openenv-core[core]>=0.2.2",
     "pydantic>=2.0.0",
-    # Environment-specific dependencies
-    # Add all dependencies needed for your environment here
-    # Examples:
-    # "numpy>=1.19.0",
-    # "torch>=2.0.0",
-    # "gymnasium>=0.29.0",
-    # "openspiel>=1.0.0",
-    # "smolagents>=1.22.0,<2",
+    "openai>=1.0.0",
+    "python-dotenv>=1.0.0",
 ]
 
 [project.optional-dependencies]

scripts/validate-submission.sh

@@ -0,0 +1,155 @@
+#!/usr/bin/env bash
+#
+# validate-submission.sh — OpenEnv Submission Validator
+#
+# Checks that your HF Space is live, Docker image builds, and openenv validate passes.
+#
+# Run:
+#   chmod +x scripts/validate-submission.sh
+#   ./scripts/validate-submission.sh <ping_url> [repo_dir]
+#
+
+set -uo pipefail
+
+DOCKER_BUILD_TIMEOUT=600
+if [ -t 1 ]; then
+  RED='\033[0;31m'
+  GREEN='\033[0;32m'
+  YELLOW='\033[1;33m'
+  BOLD='\033[1m'
+  NC='\033[0m'
+else
+  RED='' GREEN='' YELLOW='' BOLD='' NC=''
+fi
+
+pass() { echo -e "${GREEN}[PASS]${NC} $1"; }
+fail() { echo -e "${RED}[FAIL]${NC} $1"; FAILED=1; }
+warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
+info() { echo -e "${BOLD}[INFO]${NC} $1"; }
+
+FAILED=0
+
+PING_URL="${1:-}"
+REPO_DIR="${2:-.}"
+
+if [ -z "$PING_URL" ]; then
+  echo "Usage: $0 <ping_url> [repo_dir]"
+  echo "  ping_url  Your HuggingFace Space URL (e.g. https://your-space.hf.space)"
+  echo "  repo_dir  Path to your repo (default: current directory)"
+  exit 1
+fi
+
+REPO_DIR="$(cd "$REPO_DIR" && pwd)"
+
+echo ""
+echo -e "${BOLD}=== OpenEnv Submission Validator ===${NC}"
+echo ""
+
+# ---------- Check 1: Required files ----------
+info "Checking required files..."
+
+for f in openenv.yaml Dockerfile inference.py; do
+  if [ -f "$REPO_DIR/$f" ]; then
+    pass "Found $f"
+  else
+    fail "Missing $f"
+  fi
+done
+
+# ---------- Check 2: openenv.yaml ----------
+info "Checking openenv.yaml..."
+if [ -f "$REPO_DIR/openenv.yaml" ]; then
+  if grep -q "spec_version" "$REPO_DIR/openenv.yaml"; then
+    pass "openenv.yaml has spec_version"
+  else
+    fail "openenv.yaml missing spec_version"
+  fi
+  if grep -q "name:" "$REPO_DIR/openenv.yaml"; then
+    pass "openenv.yaml has name field"
+  else
+    fail "openenv.yaml missing name field"
+  fi
+fi
+
+# ---------- Check 3: inference.py structure ----------
+info "Checking inference.py structure..."
+if [ -f "$REPO_DIR/inference.py" ]; then
+  for pattern in 'API_BASE_URL' 'MODEL_NAME' 'HF_TOKEN' 'OpenAI' '"START"' '"STEP"' '"END"'; do
+    if grep -q "$pattern" "$REPO_DIR/inference.py"; then
+      pass "inference.py references $pattern"
+    else
+      fail "inference.py missing reference to $pattern"
+    fi
+  done
+fi
+
+# ---------- Check 4: Environment variables ----------
+info "Checking environment variables..."
+for var in API_BASE_URL MODEL_NAME HF_TOKEN; do
+  if [ -n "${!var:-}" ]; then
+    pass "$var is set"
+  else
+    warn "$var is not set (required at runtime)"
+  fi
+done
+
+# ---------- Check 5: Docker build ----------
+info "Checking Docker build..."
+if command -v docker &>/dev/null; then
+  info "Running docker build (timeout ${DOCKER_BUILD_TIMEOUT}s)..."
+  if timeout "$DOCKER_BUILD_TIMEOUT" docker build -t openenv-store-test "$REPO_DIR" 2>&1; then
+    pass "Docker build succeeded"
+  else
+    fail "Docker build failed"
+  fi
+else
+  warn "Docker not found — skipping Docker build check"
+fi
+
+# ---------- Check 6: HF Space ping ----------
+info "Pinging HF Space at $PING_URL ..."
+if command -v curl &>/dev/null; then
+  HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" --max-time 30 "$PING_URL/health" 2>/dev/null || echo "000")
+  if [ "$HTTP_CODE" = "200" ]; then
+    pass "HF Space /health returned 200"
+  else
+    fail "HF Space /health returned HTTP $HTTP_CODE (expected 200)"
+  fi
+
+  RESET_CODE=$(curl -s -o /dev/null -w "%{http_code}" --max-time 30 -X POST "$PING_URL/reset" 2>/dev/null || echo "000")
+  if [ "$RESET_CODE" = "200" ]; then
+    pass "HF Space /reset returned 200"
+  else
+    fail "HF Space /reset returned HTTP $RESET_CODE (expected 200)"
+  fi
+else
+  warn "curl not found — skipping ping check"
+fi
+
+# ---------- Check 7: openenv validate ----------
+info "Running openenv validate..."
+if command -v openenv &>/dev/null; then
+  if (cd "$REPO_DIR" && openenv validate .); then
+    pass "openenv validate passed"
+  else
+    fail "openenv validate failed"
+  fi
+elif command -v uv &>/dev/null && [ -f "$REPO_DIR/pyproject.toml" ]; then
+  if (cd "$REPO_DIR" && uv run --project . openenv validate .); then
+    pass "openenv validate passed (via uv)"
+  else
+    fail "openenv validate failed (via uv)"
+  fi
+else
+  warn "Neither openenv nor uv found — skipping validate"
+fi
+
+# ---------- Summary ----------
+echo ""
+if [ "$FAILED" -eq 0 ]; then
+  echo -e "${GREEN}${BOLD}All checks passed!${NC}"
+  exit 0
+else
+  echo -e "${RED}${BOLD}Some checks failed. Please fix the issues above before submitting.${NC}"
+  exit 1
+fi

server/requirements.txt

@@ -1,6 +1,7 @@
 openenv[core]>=0.2.0
 fastapi>=0.115.0
 uvicorn>=0.24.0
+openai>=1.0.0
 
 
 

uv.lock

@@ -1604,8 +1604,10 @@ version = "0.1.0"
 source = { editable = "." }
 dependencies = [
     { name = "gradio" },
+    { name = "openai" },
     { name = "openenv-core", extra = ["core"] },
     { name = "pydantic" },
+    { name = "python-dotenv" },
 ]
 
 [package.optional-dependencies]
@@ -1617,10 +1619,12 @@ dev = [
 [package.metadata]
 requires-dist = [
     { name = "gradio", specifier = ">=6.0.0" },
+    { name = "openai", specifier = ">=1.0.0" },
     { name = "openenv-core", extras = ["core"], specifier = ">=0.2.2" },
     { name = "pydantic", specifier = ">=2.0.0" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0.0" },
     { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.0.0" },
+    { name = "python-dotenv", specifier = ">=1.0.0" },
 ]
 provides-extras = ["dev"]