Upload folder using huggingface_hub

inference.py

@@ -1,47 +1,3 @@
-"""
-Inference Script Example
-===================================
-MANDATORY
-- Before submitting, ensure the following variables are defined in your environment configuration:
-    API_BASE_URL   The API endpoint for the LLM.
-    MODEL_NAME     The model identifier to use for inference.
-    HF_TOKEN       Your Hugging Face / API key.
-    LOCAL_IMAGE_NAME The name of the local image to use for the environment if you are using from_docker_image()
-                     method
-
-- Defaults are set only for API_BASE_URL and MODEL_NAME 
-    (and should reflect your active inference setup):
-    API_BASE_URL = os.getenv("API_BASE_URL", "<your-active-endpoint>")
-    MODEL_NAME = os.getenv("MODEL_NAME", "<your-active-model>")
-    
-- The inference script must be named `inference.py` and placed in the root directory of the project
-- Participants must use OpenAI Client for all LLM calls using above variables
-
-STDOUT FORMAT
-- The script must emit exactly three line types to stdout, in this order:
-
-    [START] task=<task_name> env=<benchmark> model=<model_name>
-    [STEP]  step=<n> action=<action_str> reward=<0.00> done=<true|false> error=<msg|null>
-    [END]   success=<true|false> steps=<n> score=<score> rewards=<r1,r2,...,rn>
-
-  Rules:
-    - One [START] line at episode begin.
-    - One [STEP] line per step, immediately after env.step() returns.
-    - One [END] line after env.close(), always emitted (even on exception).
-    - reward and rewards are formatted to 2 decimal places.
-    - done and success are lowercase booleans: true or false.
-    - error is the raw last_action_error string, or null if none.
-    - All fields on a single line with no newlines within a line.
-    - Each tasks should return score in [0, 1]
-
-  Example:
-    [START] task=click-test env=miniwob model=Qwen3-VL-30B
-    [STEP] step=1 action=click('123') reward=0.00 done=false error=null
-    [STEP] step=2 action=fill('456','text') reward=0.00 done=false error=null
-    [STEP] step=3 action=click('789') reward=1.00 done=true error=null
-    [END] success=true steps=3 score=1.00 rewards=0.00,0.00,1.00
-"""
-
 import asyncio
 import os
 import sys
@@ -53,7 +9,7 @@ from openai import OpenAI
 from dotenv import load_dotenv
 
 # --- PATH INJECTION ---
-# Ensures local 'client' and 'models' are prioritized over installed site-packages
+# Ensures local 'client' and 'models' are prioritized over installed packages
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
 try:
@@ -68,11 +24,14 @@ load_dotenv()
 # --- CONFIGURATION ---
 # API_KEY is sourced from HF_TOKEN for hackathon compliance
 API_KEY = os.environ.get("HF_TOKEN") or os.environ.get("API_KEY")
-# Base URL for the Hugging Face Inference Router
-API_BASE_URL = os.environ.get("API_BASE_URL") or "https://router.huggingface.co/hf-inference/v1"
+
+# MODEL IDENTIFIER
 MODEL_NAME = os.environ.get("MODEL_NAME") or "Qwen/Qwen2.5-72B-Instruct"
 
-# ADDRESS points to your Hugging Face Space API mount (/v1)
+# API_BASE_URL: Set to the model-specific v1 endpoint to bypass Router 404s
+API_BASE_URL = os.environ.get("API_BASE_URL") or f"https://api-inference.huggingface.co/models/{MODEL_NAME}/v1"
+
+# ADDRESS: Points to your Hugging Face Space API mount (/v1)
 ADDRESS = (os.environ.get("ADDRESS") or "https://anonajay-lint-coding-agent.hf.space/v1").rstrip("/")
 
 TASK_NAME = "multi-lang-lint-v1"
@@ -91,7 +50,7 @@ def log_start(task: str, env: str, model: str):
     print(f"[START] task={task} env={env} model={model}", flush=True)
 
 def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]):
-    # Ensure action string is sanitized for single-line STDOUT compliance
+    # Sanitize action string for single-line STDOUT compliance
     action_clean = str(action).replace("\n", " ").replace("\r", " ").strip()[:50]
     err_str = str(error).replace("\n", " ") if error else "null"
     print(f"[STEP] step={step} action={action_clean} reward={reward:.2f} done={str(done).lower()} error={err_str}", flush=True)
@@ -101,9 +60,8 @@ def log_end(success: bool, steps: int, score: float, rewards: List[float]):
     print(f"[END] success={str(success).lower()} steps={steps} score={score:.2f} rewards={rewards_str}", flush=True)
 
 async def main():
-    # OpenAI client pointing to the Hugging Face Router
-    # If 404 continues, ensure API_BASE_URL does not end in a slash.
-    llm_client = OpenAI(base_url=API_BASE_URL.rstrip("/"), api_key=API_KEY)
+    # OpenAI client pointing to the model-specific Hugging Face endpoint
+    llm_client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
     
     rewards, steps_taken, success = [], 0, False
     last_error = None
@@ -111,7 +69,7 @@ async def main():
     log_start(task=TASK_NAME, env=BENCHMARK, model=MODEL_NAME)
 
     try:
-        # Connecting to the Environment Space
+        # Connecting to the Environment Space with security headers
         async with LintCodingAgentEnv(
             base_url=ADDRESS,
             headers={
@@ -121,14 +79,14 @@ async def main():
             }
         ) as env:
             
-            # 🏁 Level 1 Handshake (Reset)
+            # 🏁 Initial Reset
             result = await env.reset()
             
             for step in range(1, MAX_STEPS + 1):
                 obs = result.observation
                 steps_taken = step
                 
-                # Context Construction
+                # Context Construction for the LLM
                 user_prompt = (
                     f"LEVEL: {obs.level}\n"
                     f"LANGUAGE: {obs.language}\n"
@@ -136,7 +94,7 @@ async def main():
                     f"OBJECTIVE: {obs.problem_statement}"
                 )
 
-                # LLM Inference with Wait-for-Model support
+                # LLM Inference with 'wait-for-model' to prevent 503/404 during cold starts
                 completion = llm_client.chat.completions.create(
                     model=MODEL_NAME,
                     messages=[
@@ -149,7 +107,7 @@ async def main():
                 
                 action_text = (completion.choices[0].message.content or "").strip()
                 
-                # Step Transition (Action Execution)
+                # Execute Action via the Environment Bridge
                 result = await env.step(LintCodingAgentAction(
                     code_solution=action_text,
                     explanation=f"Architect Fix: Level {obs.level}"
@@ -161,18 +119,20 @@ async def main():
                 log_step(step, action_text, current_reward, result.done, None)
                 
                 if result.done:
-                    # Success logic based on clearing the 15-level sprint
+                    # Success is defined as clearing the cumulative reward threshold
                     success = (sum(rewards) >= 1.0) 
                     break
 
     except Exception as e:
         last_error = str(e)
+        # Log the fault as a step to maintain sequence
         log_step(steps_taken + 1, "execution_fault", 0.0, True, last_error)
     
     finally:
-        # Score normalization [0, 1]
-        total_score = sum(rewards) / len(rewards) if rewards else 0.0
-        log_end(success, steps_taken, min(total_score, 1.0), rewards)
+        # Final Score Calculation (Normalized to 0.00 - 1.00)
+        avg_reward = sum(rewards) / len(rewards) if rewards else 0.0
+        # If any step succeeded (reward 1.0), success should be true for the sprint
+        log_end(success, steps_taken, min(avg_reward, 1.0), rewards)
 
 if __name__ == "__main__":
     asyncio.run(main())

server/app.py

@@ -17,7 +17,7 @@ logging.basicConfig(
 logger = logging.getLogger("ArchitectApp")
 
 # --- ARCHITECT'S PATH INJECTION ---
-# We force the root and server dirs into sys.path to ensure 'models' is found
+# Ensures 'models' and environment logic are discoverable regardless of the launch root
 current_dir = os.path.dirname(os.path.abspath(__file__))
 project_root = os.path.abspath(os.path.join(current_dir, ".."))
 
@@ -32,12 +32,11 @@ except ImportError:
     from openenv.core.env_server.http_server import create_app
 
 # --- DOMAIN SPECIFIC IMPORTS ---
-# These are the schemas and logic we verified in previous steps
 from models import LintCodingAgentAction, LintCodingAgentObservation
 from server.lint_coding_agent_environment import LintCodingAgentEnvironment
 
 # --- APP FACTORY ---
-# 1. Create the environment logic app (The core OpenEnv engine)
+# 1. Create the internal OpenEnv engine first
 base_app = create_app(
     LintCodingAgentEnvironment,
     LintCodingAgentAction,
@@ -45,26 +44,30 @@ base_app = create_app(
 )
 
 # 2. Create the Main Wrapper App
-# redirect_slashes=False is CRITICAL to prevent 307 Redirect loops on HF
+# redirect_slashes=False is non-negotiable for Hugging Face Proxy stability
 app = FastAPI(
     title="AnonAjay Architect API",
     redirect_slashes=False
 )
 
 # --- DEBUG MIDDLEWARE ---
-# Real-time telemetry for every request hitting the Space
 @app.middleware("http")
 async def debug_logging(request: Request, call_next):
-    logger.info(f"📡 Request: {request.method} {request.url.path}")
+    logger.info(f"📡 Incoming: {request.method} {request.url.path}")
     response = await call_next(request)
     logger.info(f"✅ Outcome: {response.status_code}")
     return response
 
-# --- MOUNTING (The /v1 Fix) ---
-# This ensures that /v1/reset and /v1/ws are mapped to the core engine
+# --- MOUNTING (The "Zero-Failure" Strategy) ---
+# Explicitly map the root of /v1 to prevent the 404s seen in previous logs
+@app.get("/v1")
+async def v1_root():
+    return {"message": "OpenEnv API Root Active", "docs": "/v1/docs"}
+
+# Mount the OpenEnv engine at /v1
 app.mount("/v1", base_app)
 
-# --- CORS SECURITY ---
+# --- CORS & HEALTH ---
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -75,39 +78,31 @@ app.add_middleware(
 
 @app.get("/health")
 def health_check():
-    """Simple health probe for Docker and HF status checks."""
-    return {"status": "online", "message": "Lead Architect Server is Active", "port": 7860}
+    """Heartbeat for Hugging Face and Docker health monitors."""
+    return {"status": "online", "port": 7860, "vfs_ready": True}
 
-# Catch-all for the root to prevent confusing 404s in the browser
 @app.get("/")
-def root_info():
+def root_redirect():
+    """Provides a clear map for manual verification."""
     return {
-        "message": "Lint Coding Agent API is Running",
-        "endpoints": {
-            "docs": "/v1/docs",
-            "health": "/health",
-            "api_root": "/v1"
-        }
+        "message": "Lead Architect Server Live",
+        "v1_docs": "/v1/docs",
+        "health": "/health"
     }
 
 def main():
-    """
-    Entry point for the OpenEnv Server.
-    Standardized to port 7860 for Hugging Face deployment.
-    """
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--host", type=str, default="0.0.0.0")
-    parser.add_argument("--port", type=int, default=7860)
-    args = parser.parse_args()
+    """Standardized entry point for Hugging Face Spaces."""
+    # Use environment PORT or default to 7860
+    port = int(os.environ.get("PORT", 7860))
     
-    logger.info(f"🚀 OpenEnv Sandbox Starting on {args.host}:{args.port}")
-    logger.info(f"📍 Geometry: /v1 mapped to OpenEnv Core")
+    logger.info(f"🚀 Launching OpenEnv Sandbox on Port {port}")
+    logger.info(f"📍 Geometry: /v1 mounted with redirect_slashes=False")
     
     # proxy_headers + forwarded_allow_ips are vital for HF reverse proxy support
     uvicorn.run(
         app, 
-        host=args.host, 
-        port=args.port, 
+        host="0.0.0.0", 
+        port=port, 
         proxy_headers=True, 
         forwarded_allow_ips="*"
     )