fix(inference): resolve connection exception and align ports to 8002

- fix: asyncio connection exception by adding wait_for_server retry logic
- feat: implement structured logging [START], [STEP], [END] for hackathon validation
- chore: unify app port to 8002 across Dockerfile, app.py, README.md, and openenv.yaml
- chore: use mandated environment variables (API_BASE_URL, MODEL_NAME, HF_TOKEN)
- docs: update project summary and reminders

Dockerfile

@@ -20,15 +20,15 @@ COPY . .
 
 # Set environment variables
 ENV PYTHONPATH="/app"
-ENV PORT=7860
+ENV PORT=8002
 ENV HOST=0.0.0.0
 
 # Expose the app port
-EXPOSE 7860
+EXPOSE 8002
 
 # Health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:7860/health || exit 1
+    CMD curl -f http://localhost:8002/health || exit 1
 
 # Start the server
-CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8002"]

README.md

@@ -3,7 +3,7 @@ title: MedTriage OpenEnv
 emoji: 🏥
 sdk: docker
 pinned: false
-app_port: 7860
+app_port: 8002
 tags:
   - openenv
   - healthcare

REMINDERS.md

@@ -0,0 +1,16 @@
+# 🗓️ Hackathon Schedule & Reminders
+
+## 🚀 Key Dates
+- **April 8, 2026**: Round 1 Submission Deadline (Completed ✓)
+- **April 10, 2026**: Round 1 Results Announcement 🔔
+- **April 25-26, 2026**: Grand Finale (If qualified)
+
+## 🔗 Links
+- **Dashboard**: [Meta PyTorch Hackathon Dashboard](https://www.scaler.com/school-of-technology/meta-pytorch-hackathon/dashboard)
+- **Hugging Face Space**: [ashdev/med-triage-openenv](https://huggingface.co/spaces/ashdev/med-triage-openenv)
+- **GitHub Repo**: [ash399/med-triage-openenv](https://github.com/ash399/med-triage-openenv)
+
+## 📝 Post-Submission Notes
+- All automated checks passed on March 30th.
+- Environment is running on port 7860.
+- `PROJECT_SUMMARY.md` contains the full technical breakdown.

inference.py

@@ -3,44 +3,138 @@
 
 import os
 import time
-import subprocess
+import json
 import requests
+import asyncio
+from typing import List, Dict, Any
 from client import MedTriageEnv
 
+# --- Mandatory Environment Configuration ---
+API_BASE_URL = os.getenv("API_BASE_URL", "http://localhost:8002/v1")
+MODEL_NAME = os.getenv("MODEL_NAME", "med-triage-baseline")
+HF_TOKEN = os.getenv("HF_TOKEN", "dummy-token")
+
+# --- Structured Logging Functions ---
+def log_start(task: str, env: str, model: str):
+    """Emit structured [START] log."""
+    data = {
+        "timestamp": time.time(),
+        "task": task,
+        "env": env,
+        "model": model,
+        "config": {
+            "api_base": API_BASE_URL,
+            "max_steps": 10
+        }
+    }
+    print(f"[START] {json.dumps(data)}", flush=True)
+
+def log_step(step: int, action: Any, reward: float, done: bool, error: str = None):
+    """Emit structured [STEP] log."""
+    data = {
+        "timestamp": time.time(),
+        "step": step,
+        "action": action,
+        "reward": reward,
+        "done": done,
+        "error": error
+    }
+    print(f"[STEP] {json.dumps(data)}", flush=True)
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]):
+    """Emit structured [END] log."""
+    data = {
+        "timestamp": time.time(),
+        "success": success,
+        "steps_taken": steps,
+        "score": score,
+        "rewards": rewards
+    }
+    print(f"[END] {json.dumps(data)}", flush=True)
+
+# --- Server Readiness Check ---
+def wait_for_server(url: str, timeout: int = 30):
+    """Wait for the server to be ready before proceeding."""
+    start_time = time.time()
+    health_url = f"{url.rstrip('/')}/health"
+    
+    while time.time() - start_time < timeout:
+        try:
+            response = requests.get(health_url, timeout=2)
+            if response.status_code == 200:
+                return True
+        except (requests.RequestException, ConnectionError):
+            pass
+        time.sleep(1)
+    return False
+
 def run_baseline(base_url: str = "http://localhost:8002"):
     """Run baseline agent against all 3 tasks and return results."""
-    print(f"🚀 Starting MedTriage Baseline Inference on {base_url}...")
-    
+    # Ensure base_url uses the port from environment if available
+    env_port = os.environ.get("PORT", "8002")
+    if "localhost" in base_url and f":{env_port}" not in base_url:
+        base_url = f"http://localhost:{env_port}"
+
+    # Wait for server readiness
+    wait_for_server(base_url)
+
     tasks = ["TASK_EASY", "TASK_MEDIUM", "TASK_HARD"]
-    scores = {}
+    all_scores = {}
     
-    # Simple heuristic-based baseline (no LLM required for this local test)
     try:
         from client import MedTriageEnv
     except ImportError:
         from .client import MedTriageEnv
 
-    with MedTriageEnv(base_url=base_url).sync() as env:
-        for task_id in tasks:
-            print(f"📋 Running {task_id}...", end=" ", flush=True)
-            obs = env.reset(task_id=task_id)
-            
-            # Simple heuristic logic
-            bp_sys = int(obs.vitals.get("bp", "120/80").split("/")[0])
-            
-            if bp_sys > 150 or obs.age > 65:
-                level = 3 # EMERGENCY
-            elif "severe pain" in obs.symptoms_text.lower():
-                level = 2 # URGENT_CARE
-            else:
-                level = 0 # SELF_CARE
+    for task_id in tasks:
+        log_start(task=task_id, env="med_triage_env", model=MODEL_NAME)
+        
+        rewards = []
+        steps_taken = 0
+        success = False
+        final_score = 0.0
+        
+        try:
+            with MedTriageEnv(base_url=base_url).sync() as env:
+                obs = env.reset(task_id=task_id)
+                steps_taken = 1
+                
+                # Heuristic Logic (mimes model output)
+                bp_sys = int(obs.vitals.get("bp", "120/80").split("/")[0])
+                if bp_sys > 150 or obs.age > 65:
+                    level = 3 # EMERGENCY
+                elif "severe pain" in obs.symptoms_text.lower():
+                    level = 2 # URGENT_CARE
+                else:
+                    level = 0 # SELF_CARE
+                
+                action = {"tool_name": "triage_patient", "arguments": {"level": level, "reasoning": "Heuristic baseline."}}
+                result = env.step(action)
+                
+                reward = result.reward or 0.0
+                done = result.done
+                rewards.append(reward)
                 
-            result = env.step({"tool_name": "triage_patient", "arguments": {"level": level, "reasoning": "Heuristic baseline."}})
-            scores[task_id] = result.reward
-            print(f"Score: {result.reward}")
+                log_step(step=1, action=action, reward=reward, done=done)
+                
+                final_score = reward
+                success = reward >= 1.0
+                all_scores[task_id] = reward
+                
+        except Exception as e:
+            log_step(step=steps_taken, action=None, reward=0.0, done=True, error=str(e))
+            all_scores[task_id] = 0.0
             
-    return scores
+        log_end(success=success, steps=steps_taken, score=final_score, rewards=rewards)
+            
+    return all_scores
 
 if __name__ == "__main__":
-    results = run_baseline()
-    print("\n📊 FINAL BASELINE SCORES:", results)
+    try:
+        results = run_baseline()
+        # Final summary for human readability
+        print(f"\n📊 FINAL BASELINE SCORES: {results}")
+    except Exception as e:
+        print(f"FATAL: {e}")
+        import sys
+        sys.exit(1)

server/app.py

@@ -70,9 +70,12 @@ async def trigger_baseline():
         if parent_dir not in sys.path:
             sys.path.append(parent_dir)
         from inference import run_baseline
-        
+    
+    # Get current port from environment or default to 8002
+    port = os.environ.get("PORT", "8002")
+    
     # Execute actual baseline
-    scores = run_baseline(base_url="http://localhost:7860")
+    scores = run_baseline(base_url=f"http://localhost:{port}")
     
     return {
         "status": "baseline_completed",
@@ -81,7 +84,9 @@ async def trigger_baseline():
 
 def main():
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    import os
+    port = int(os.environ.get("PORT", 8002))
+    uvicorn.run(app, host="0.0.0.0", port=port)
 
 if __name__ == "__main__":
     main()