LLM openai fixed

Dockerfile

@@ -5,16 +5,14 @@ FROM ghcr.io/meta-pytorch/openenv-base:latest AS builder
 WORKDIR /app
 
 ARG BUILD_MODE=in-repo
-
 COPY . /app/env
-
 WORKDIR /app/env
 
 # Ensure uv is available
 RUN if ! command -v uv >/dev/null 2>&1; then \
-        curl -LsSf https://astral.sh/uv/install.sh | sh && \
-        mv /root/.local/bin/uv /usr/local/bin/uv && \
-        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    curl -LsSf https://astral.sh/uv/install.sh | sh && \
+    mv /root/.local/bin/uv /usr/local/bin/uv && \
+    mv /root/.local/bin/uvx /usr/local/bin/uvx; \
     fi
 
 # Install git for git-based deps
@@ -38,7 +36,7 @@ FROM ghcr.io/meta-pytorch/openenv-base:latest
 WORKDIR /app
 
 COPY --from=builder /app/env/.venv /app/.venv
-COPY --from=builder /app/env /app/env
+COPY --from=builder /app/env      /app/env
 
 ENV PATH="/app/.venv/bin:$PATH"
 ENV PYTHONPATH="/app/env:$PYTHONPATH"
@@ -49,4 +47,5 @@ HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
 
 EXPOSE 8000
 
-CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]
+# Start the MCP server in background, wait for it to be ready, then run inference
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000 & sleep 5 && python inference.py"]

inference.py

@@ -4,15 +4,15 @@ Inference Script — CSV Cleaner Environment
 Baseline agent using OpenAI client to clean CSV datasets across 3 tasks.
 
 MANDATORY ENV VARS:
-    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.
-    IMAGE_NAME     Docker image name (if using from_docker_image)
+  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.
+  IMAGE_NAME     Docker image name (if using from_docker_image)
 
 STDOUT FORMAT:
-    [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>
+  [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>
 """
 
 import asyncio
@@ -25,40 +25,44 @@ from openai import OpenAI
 
 from csv_cleaner_env import CsvCleanerEnv
 
-IMAGE_NAME = os.environ.get("IMAGE_NAME", os.environ.get("LOCAL_IMAGE_NAME"))
-API_KEY = os.environ.get("API_KEY", os.environ.get("HF_TOKEN"))
-API_BASE_URL = os.environ.get("API_BASE_URL", "https://router.huggingface.co/v1")
-MODEL_NAME = os.environ.get("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
-BENCHMARK = os.getenv("CSV_CLEANER_BENCHMARK", "csv_cleaner_env")
+IMAGE_NAME   = os.getenv("IMAGE_NAME")
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")  # default allowed
+MODEL_NAME   = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")           # default allowed
+HF_TOKEN     = os.getenv("HF_TOKEN")                                           # NO default — injected by validator
+
+BENCHMARK   = os.getenv("CSV_CLEANER_BENCHMARK", "csv_cleaner_env")
 TEMPERATURE = 0.3
-MAX_TOKENS = 300
+MAX_TOKENS  = 300
+
+# Debug print to confirm env vars are loaded
+print(f"[CONFIG] API_BASE_URL={API_BASE_URL} MODEL={MODEL_NAME} HF_TOKEN={'SET' if HF_TOKEN else 'NOT SET'}", flush=True)
 
 # Task configurations
 TASKS = [
-    {"name": "fix_column_types", "max_steps": 10},
-    {"name": "clean_missing_duplicates", "max_steps": 15},
-    {"name": "full_pipeline", "max_steps": 20},
+    {"name": "fix_column_types",          "max_steps": 10},
+    {"name": "clean_missing_duplicates",  "max_steps": 15},
+    {"name": "full_pipeline",             "max_steps": 20},
 ]
 
 SYSTEM_PROMPT = textwrap.dedent("""
-You are a data cleaning agent. You interact with a CSV dataset through structured tool calls.
-
-Available tools:
-- get_dataset_info(): See current columns, types, null counts, samples
-- rename_column(old_name, new_name): Rename a column
-- cast_column(column, dtype): Cast column to int/float/str/datetime
-- fill_missing(column, strategy, value): Fill nulls. strategy: mean/median/mode/constant/zero
-- drop_missing(column): Drop rows with nulls (empty string for all columns)
-- drop_duplicates(columns): Remove duplicates (empty string for all columns)
-- filter_rows(column, operator, value): Filter rows. operator: ==/!=/>/</contains
-- strip_whitespace(column): Strip whitespace from string column
-- replace_values(column, old_value, new_value): Replace values in column
-
-You must respond with EXACTLY ONE tool call per turn as a JSON object:
-{"tool": "<tool_name>", "args": {"param1": "value1", ...}}
-
-Read the task description carefully and execute the cleaning steps one at a time.
-Start by calling get_dataset_info to understand the current state, then fix issues.
+    You are a data cleaning agent. You interact with a CSV dataset through structured tool calls.
+
+    Available tools:
+    - get_dataset_info(): See current columns, types, null counts, samples
+    - rename_column(old_name, new_name): Rename a column
+    - cast_column(column, dtype): Cast column to int/float/str/datetime
+    - fill_missing(column, strategy, value): Fill nulls. strategy: mean/median/mode/constant/zero
+    - drop_missing(column): Drop rows with nulls (empty string for all columns)
+    - drop_duplicates(columns): Remove duplicates (empty string for all columns)
+    - filter_rows(column, operator, value): Filter rows. operator: ==/!=/>/</contains
+    - strip_whitespace(column): Strip whitespace from string column
+    - replace_values(column, old_value, new_value): Replace values in column
+
+    You must respond with EXACTLY ONE tool call per turn as a JSON object:
+    {"tool": "<tool_name>", "args": {"param1": "value1", ...}}
+
+    Read the task description carefully and execute the cleaning steps one at a time.
+    Start by calling get_dataset_info to understand the current state, then fix issues.
 """).strip()
 
 
@@ -68,7 +72,7 @@ def log_start(task: str, env: str, model: str) -> None:
 
 def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
     error_val = error if error else "null"
-    done_val = str(done).lower()
+    done_val  = str(done).lower()
     print(
         f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}",
         flush=True,
@@ -86,23 +90,21 @@ def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> No
 def parse_tool_call(text: str) -> Optional[Dict[str, Any]]:
     """Extract JSON tool call from model response."""
     text = text.strip()
-    # Try to find JSON in the response
-    for start_char, end_char in [("{", "}"), ]:
+    for start_char in ["{"]:
         start = text.find(start_char)
         if start == -1:
             continue
-        # Find matching closing brace
         depth = 0
         for i in range(start, len(text)):
             if text[i] == "{":
                 depth += 1
             elif text[i] == "}":
                 depth -= 1
-                if depth == 0:
-                    try:
-                        return json.loads(text[start : i + 1])
-                    except json.JSONDecodeError:
-                        continue
+            if depth == 0:
+                try:
+                    return json.loads(text[start : i + 1])
+                except json.JSONDecodeError:
+                    continue
     return None
 
 
@@ -116,19 +118,20 @@ def get_model_response(
 ) -> Optional[Dict[str, Any]]:
     """Get next tool call from the model."""
     history_block = "\n".join(history[-6:]) if history else "None"
+
     user_prompt = textwrap.dedent(f"""
-Task: {task_desc}
+        Task: {task_desc}
 
-Current Step: {step}
-Last Action Result: {last_result}
+        Current Step: {step}
+        Last Action Result: {last_result}
 
-Current Dataset State:
-{dataset_info}
+        Current Dataset State:
+        {dataset_info}
 
-Previous Actions:
-{history_block}
+        Previous Actions:
+        {history_block}
 
-Respond with your next tool call as JSON: {{"tool": "tool_name", "args": {{...}}}}
+        Respond with your next tool call as JSON: {{"tool": "tool_name", "args": {{...}}}}
     """).strip()
 
     try:
@@ -136,7 +139,7 @@ Respond with your next tool call as JSON: {{"tool": "tool_name", "args": {{...}}
             model=MODEL_NAME,
             messages=[
                 {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": user_prompt},
+                {"role": "user",   "content": user_prompt},
             ],
             temperature=TEMPERATURE,
             max_tokens=MAX_TOKENS,
@@ -156,18 +159,17 @@ async def run_task(client: OpenAI, env: CsvCleanerEnv, task_config: Dict) -> Non
 
     log_start(task=task_name, env=BENCHMARK, model=MODEL_NAME)
 
-    rewards: List[float] = []
-    steps_taken = 0
-    score = 0.0
-    success = False
+    rewards:     List[float] = []
+    steps_taken: int         = 0
+    score:       float       = 0.0
+    success:     bool        = False
 
     try:
-        result = await env.reset(task=task_name)
-        metadata = result.metadata or {}
-        task_desc = metadata.get("task_description", task_name)
+        result     = await env.reset(task=task_name)
+        metadata   = result.metadata or {}
+        task_desc  = metadata.get("task_description", task_name)
         dataset_info = json.dumps(metadata.get("columns", []), indent=2)
-        last_result = metadata.get("last_action_result", "Ready")
-
+        last_result  = metadata.get("last_action_result", "Ready")
         history: List[str] = []
 
         for step in range(1, max_steps + 1):
@@ -181,48 +183,39 @@ async def run_task(client: OpenAI, env: CsvCleanerEnv, task_config: Dict) -> Non
                 tool_call = get_model_response(
                     client, task_desc, dataset_info, last_result, step, history
                 )
-
-            if tool_call is None:
-                tool_call = {"tool": "get_dataset_info", "args": {}}
+                if tool_call is None:
+                    tool_call = {"tool": "get_dataset_info", "args": {}}
 
             tool_name = tool_call.get("tool", "get_dataset_info")
             tool_args = tool_call.get("args", {})
 
-            # Execute via MCP call_tool
             try:
                 call_result = await env.call_tool(tool_name, **tool_args)
-                result_str = str(call_result) if call_result else ""
+                result_str  = str(call_result) if call_result else ""
             except Exception as e:
                 result_str = f"Error: {e}"
 
-            # Get updated observation via step
-            # The call_tool already executed the step internally via MCP
-            # We need to read the reward from the observation
             reward = result.reward if hasattr(result, "reward") and result.reward else 0.0
-            done = result.done if hasattr(result, "done") else False
+            done   = result.done   if hasattr(result, "done")   else False
 
-            # If the tool call was successful, try to extract progress
             if result.metadata:
-                progress = result.metadata.get("progress", 0.0)
-                score = progress
+                progress     = result.metadata.get("progress", 0.0)
+                score        = progress
                 dataset_info = json.dumps(result.metadata.get("columns", []), indent=2)
-                last_result = result.metadata.get("last_action_result", result_str)
+                last_result  = result.metadata.get("last_action_result", result_str)
             else:
                 last_result = result_str
 
             rewards.append(reward)
             steps_taken = step
-
-            action_str = f"{tool_name}({json.dumps(tool_args)})"
+            action_str  = f"{tool_name}({json.dumps(tool_args)})"
             log_step(step=step, action=action_str, reward=reward, done=done, error=None)
-
             history.append(f"Step {step}: {action_str} -> {last_result[:100]}")
 
             if done:
                 break
 
-        # Final score = last progress value
-        score = min(max(score, 0.0), 1.0)
+        score   = min(max(score, 0.0), 1.0)
         success = score >= 0.5
 
     except Exception as e:
@@ -232,10 +225,10 @@ async def run_task(client: OpenAI, env: CsvCleanerEnv, task_config: Dict) -> Non
 
 
 async def main() -> None:
-    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+    # Use HF_TOKEN as the API key — injected by the hackathon validator
+    client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
 
     env = await CsvCleanerEnv.from_docker_image(IMAGE_NAME)
-
     try:
         for task_config in TASKS:
             await run_task(client, env, task_config)
@@ -247,4 +240,4 @@ async def main() -> None:
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

test_remote.py

@@ -0,0 +1,29 @@
+import asyncio
+from client import CsvCleanerEnv
+try:
+    from server.tasks import TASKS
+except ImportError:
+    TASKS = {"fix_column_types": None, "clean_missing_duplicates": None, "full_pipeline": None}
+
+async def test_space():
+    url = "https://printf-sourav-csv-dc-env.hf.space"
+    print(f"Connecting to {url}...")
+    try:
+        env = CsvCleanerEnv(base_url=url)
+        for task_name in TASKS.keys():
+            print(f"\\nTesting task: {task_name}")
+            result = await env.reset(task=task_name)
+            print(f"✅ Reset successful. Result: {result}")
+            
+            # test one simple MCP call
+            tools = await env.list_tools()
+            if "get_dataset_info" in tools:
+                print("✅ Toolkit active.")
+                
+        await env.close()
+        print("\\nAll tasks reachable and responsive in HF Space!")
+    except Exception as e:
+        print(f"Failed to connect or test: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(test_space())