Initial submission: API Debug Environment

.dockerignore

@@ -0,0 +1,9 @@
+.git
+.env
+__pycache__
+*.pyc
+*.pyo
+outputs/
+.venv
+uv.lock
+*.egg-info

.env.example

@@ -0,0 +1,4 @@
+API_BASE_URL=https://api-inference.huggingface.co/v1
+MODEL_NAME=mistralai/Mistral-7B-Instruct-v0.3
+HF_TOKEN=hf_your_token_here
+ENV_URL=https://YOUR-USERNAME-api-debug-env.hf.space

__init__.py

@@ -0,0 +1,4 @@
+from .models import APIAction, APIObservation, APIState
+from .client import APIDebugEnv
+
+__all__ = ["APIAction", "APIObservation", "APIState", "APIDebugEnv"]

api_debug_env.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: api-debug-env
+Version: 1.0.0
+Summary: OpenEnv environment for AI-powered HTTP API debugging
+Requires-Python: >=3.10
+Requires-Dist: openenv-core>=0.2.3
+Requires-Dist: fastapi>=0.104.0
+Requires-Dist: uvicorn>=0.24.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: openai>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"

api_debug_env.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+pyproject.toml
+api_debug_env.egg-info/PKG-INFO
+api_debug_env.egg-info/SOURCES.txt
+api_debug_env.egg-info/dependency_links.txt
+api_debug_env.egg-info/requires.txt
+api_debug_env.egg-info/top_level.txt
+graders/__init__.py
+graders/grader.py
+server/__init__.py
+server/api_debug_environment.py
+server/app.py
+server/mock_api.py
+tasks/__init__.py
+tasks/easy.py
+tasks/hard.py
+tasks/medium.py
+tasks/registry.py

api_debug_env.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

api_debug_env.egg-info/requires.txt

@@ -0,0 +1,11 @@
+openenv-core>=0.2.3
+fastapi>=0.104.0
+uvicorn>=0.24.0
+pydantic>=2.0.0
+httpx>=0.27.0
+python-dotenv>=1.0.0
+openai>=1.0.0
+
+[dev]
+pytest>=7.0
+pytest-asyncio>=0.21

api_debug_env.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+graders
+server
+tasks

client.py

@@ -0,0 +1,12 @@
+from openenv.core.client import EnvClient
+from models import APIAction, APIObservation, APIState
+
+
+class APIDebugEnv(EnvClient[APIAction, APIObservation, APIState]):
+
+    def __init__(self, base_url: str = "http://localhost:8000"):
+        super().__init__(
+            base_url=base_url,
+            action_type=APIAction,
+            observation_type=APIObservation,
+        )

graders/__init__.py

@@ -0,0 +1 @@
+# empty

graders/grader.py

@@ -0,0 +1,40 @@
+import json
+
+
+class APIGrader:
+
+    def grade(self, response_status, response_body, expected_status, expected_schema, attempt, max_steps):
+        if response_status != expected_status:
+            return self._partial(response_status)
+        try:
+            body = json.loads(response_body)
+        except Exception:
+            return 0.1
+        schema_score = self._schema_match(body, expected_schema)
+        attempt_bonus = max(0.0, 1.0 - (attempt / max_steps) * 0.15)
+        return round(min(1.0, max(0.0, schema_score * attempt_bonus)), 4)
+
+    def _partial(self, status):
+        mapping = {0: 0.0, 401: 0.05, 403: 0.05, 404: 0.05, 405: 0.10, 415: 0.10, 422: 0.15, 429: 0.20, 200: 0.70}
+        return mapping.get(status, 0.05)
+
+    def _schema_match(self, body, schema):
+        if not schema:
+            return 1.0
+        matched = sum(1 for k, v in schema.items() if k in body and type(body[k]) == type(v))
+        return matched / len(schema)
+
+    def get_feedback(self, status, expected_status):
+        if status == expected_status:
+            return "Correct status code. Verify response schema matches expected."
+        hints = {
+            401: "Authentication failed. Check Authorization header format and token value.",
+            403: "Forbidden. Token valid but lacks permission.",
+            404: "Endpoint not found. Check the URL path.",
+            405: "Wrong HTTP method. Check if endpoint needs GET POST PUT or DELETE.",
+            415: "Wrong Content-Type. Send application/json.",
+            422: "Body validation failed. Check field names types and required fields.",
+            429: "Rate limited. Add header X-Retry-After: 2 on next request.",
+            500: "Server error. Your payload caused an exception.",
+        }
+        return hints.get(status, f"Got {status} expected {expected_status}. Re-read task description carefully.")

inference.py

@@ -0,0 +1,138 @@
+import os
+import json
+import asyncio
+from openai import OpenAI
+from client import APIDebugEnv
+from models import APIAction
+
+API_BASE_URL = os.environ["API_BASE_URL"]
+MODEL_NAME = os.environ["MODEL_NAME"]
+HF_TOKEN = os.environ["HF_TOKEN"]
+ENV_URL = os.environ.get("ENV_URL", "http://localhost:8000")
+
+llm = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+
+SYSTEM_PROMPT = """You are an HTTP API debugger. You receive a broken request and must fix it to get HTTP 200.
+Respond ONLY in valid JSON with exactly these fields:
+{
+  "method": "GET",
+  "url": "/mock_api/...",
+  "headers": {},
+  "body": null,
+  "query_params": {}
+}
+Rules:
+- method must be uppercase
+- url must start with /mock_api/
+- body must be null for GET requests
+- always include Content-Type: application/json when body is not null
+- do not add any text outside the JSON"""
+
+
+def call_llm(task_description, broken_request, last_status, last_body, feedback):
+    user_msg = (
+        f"Task: {task_description}\n\n"
+        f"Broken request:\n{json.dumps(broken_request, indent=2)}\n\n"
+        f"Last response status: {last_status}\n"
+        f"Last response body: {last_body[:300]}\n\n"
+        f"Feedback: {feedback}\n\n"
+        f"Return the fixed request as JSON:"
+    )
+    resp = llm.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_msg},
+        ],
+        max_tokens=300,
+        temperature=0.1,
+    )
+    raw = resp.choices[0].message.content.strip()
+    raw = raw.replace("```json", "").replace("```", "").strip()
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        return broken_request
+
+
+async def run_task(env, task_id):
+    obs = await env.reset(task_id=task_id)
+    state = await env.state()
+
+    print(json.dumps({
+        "type": "[START]",
+        "task_id": task_id,
+        "episode_id": state.episode_id,
+        "task_description": obs.task_description,
+        "broken_request": obs.broken_request,
+    }))
+
+    final_reward = 0.0
+    step_num = 0
+
+    for step_num in range(state.max_steps):
+        fixed = call_llm(
+            obs.task_description,
+            obs.broken_request,
+            obs.last_status_code,
+            obs.last_response_body,
+            obs.step_feedback,
+        )
+
+        action = APIAction(
+            method=str(fixed.get("method", "GET")),
+            url=str(fixed.get("url", obs.broken_request.get("url", "/mock_api/users"))),
+            headers=dict(fixed.get("headers") or {}),
+            body=fixed.get("body"),
+            query_params=dict(fixed.get("query_params") or {}),
+        )
+
+        result = await env.step(action)
+        final_reward = result.reward
+        obs = result.observation
+
+        print(json.dumps({
+            "type": "[STEP]",
+            "task_id": task_id,
+            "step": step_num + 1,
+            "action": {
+                "method": action.method,
+                "url": action.url,
+                "headers": action.headers,
+                "body": action.body,
+                "query_params": action.query_params,
+            },
+            "status_code": obs.last_status_code,
+            "reward": result.reward,
+            "done": result.done,
+            "feedback": obs.step_feedback,
+        }))
+
+        if result.done:
+            break
+
+    print(json.dumps({
+        "type": "[END]",
+        "task_id": task_id,
+        "final_reward": final_reward,
+        "steps_taken": step_num + 1,
+    }))
+
+    return final_reward
+
+
+async def main():
+    async with APIDebugEnv(base_url=ENV_URL) as env:
+        scores = {}
+        for task_id in ["easy", "medium", "hard"]:
+            scores[task_id] = await run_task(env, task_id)
+
+        print(json.dumps({
+            "type": "[SUMMARY]",
+            "scores": scores,
+            "average": round(sum(scores.values()) / len(scores), 4),
+        }))
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

models.py

@@ -0,0 +1,35 @@
+from openenv.core.env_server import Environment
+try:
+    from openenv.core.env_server.types import Action, Observation, State
+except ImportError:
+    from openenv.core.models import Action, Observation, State
+from pydantic import Field
+from typing import Optional
+
+
+class APIAction(Action):
+    method: str = Field(default="GET")
+    url: str = Field(default="/mock_api/users")
+    headers: dict = Field(default_factory=dict)
+    body: Optional[dict] = Field(default=None)
+    query_params: dict = Field(default_factory=dict)
+
+
+class APIObservation(Observation):
+    task_id: str = Field(default="easy")
+    task_description: str = Field(default="")
+    broken_request: dict = Field(default_factory=dict)
+    last_status_code: int = Field(default=0)
+    last_response_headers: dict = Field(default_factory=dict)
+    last_response_body: str = Field(default="")
+    step_feedback: str = Field(default="")
+    current_score: float = Field(default=0.0)
+    attempt: int = Field(default=0)
+    reward: float = Field(default=0.0)
+    done: bool = Field(default=False)
+
+
+class APIState(State):
+    task_id: str = Field(default="easy")
+    max_steps: int = Field(default=5)
+    solved: bool = Field(default=False)

openenv.yaml

@@ -0,0 +1,42 @@
+spec_version: 1
+name: api-debug-env
+version: "1.0.0"
+type: environment
+runtime: docker
+app: server/app.py
+port: 8000
+description: OpenEnv environment where AI agents debug broken HTTP API requests by reading real error responses and iteratively fixing headers, methods, bodies, and auth flows.
+tasks:
+  - id: easy
+    name: Auth and Header Errors
+    difficulty: easy
+    max_steps: 5
+    reward_range: [0.0, 1.0]
+  - id: medium
+    name: Method and Body Errors
+    difficulty: medium
+    max_steps: 5
+    reward_range: [0.0, 1.0]
+  - id: hard
+    name: Rate Limiting and Multi-step Auth
+    difficulty: hard
+    max_steps: 5
+    reward_range: [0.0, 1.0]
+action_space:
+  type: structured
+  fields:
+    - method: string
+    - url: string
+    - headers: dict
+    - body: dict
+    - query_params: dict
+observation_space:
+  type: structured
+  fields:
+    - task_id: string
+    - task_description: string
+    - broken_request: dict
+    - last_status_code: int
+    - last_response_body: string
+    - step_feedback: string
+    - current_score: float

outputs/evals/.gitkeep

@@ -0,0 +1 @@
+# empty file

outputs/logs/.gitkeep

@@ -0,0 +1 @@
+# empty file

pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "api-debug-env"
+version = "1.0.0"
+description = "OpenEnv environment for AI-powered HTTP API debugging"
+requires-python = ">=3.10"
+dependencies = [
+    "openenv-core>=0.2.3",
+    "fastapi>=0.104.0",
+    "uvicorn>=0.24.0",
+    "pydantic>=2.0.0",
+    "httpx>=0.27.0",
+    "python-dotenv>=1.0.0",
+    "openai>=1.0.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "pytest-asyncio>=0.21"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["server*", "tasks*", "graders*", "models*", "client*"]
+
+[tool.uv.scripts]
+server = "uvicorn server.app:app --host 0.0.0.0 --port 8000"

reset.json

@@ -0,0 +1 @@
+{"task_id": "easy"}

server/Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.11-slim
+
+RUN useradd -m -u 1000 envuser
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y gcc curl && rm -rf /var/lib/apt/lists/*
+
+COPY server/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+RUN pip install --no-cache-dir -e .
+
+ENV PYTHONPATH=/app
+
+USER envuser
+EXPOSE 8000
+
+HEALTHCHECK --interval=20s --timeout=8s --start-period=40s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "1"]

server/__init__.py

@@ -0,0 +1 @@
+# empty

server/api_debug_environment.py

@@ -0,0 +1,102 @@
+import random
+import httpx
+
+try:
+    from openenv.core.env_server import Environment
+except ImportError:
+    from openenv.core.env_server.interfaces import Environment
+
+from models import APIAction, APIObservation, APIState
+from tasks.registry import TASK_REGISTRY
+from graders.grader import APIGrader
+
+GRADER = APIGrader()
+MOCK_BASE = "http://localhost:8000"
+
+
+class APIDebugEnvironment(Environment):
+
+    def __init__(self):
+        self._state = APIState(episode_id="init", step_count=0, task_id="easy", max_steps=5, solved=False)
+        self._current_task = None
+
+    def reset(self, task_id: str = "easy", **kwargs) -> APIObservation:
+        if task_id not in TASK_REGISTRY:
+            task_id = "easy"
+        self._current_task = random.choice(TASK_REGISTRY[task_id])
+        self._state = APIState(
+            episode_id=f"ep_{random.randint(10000, 99999)}",
+            step_count=0,
+            task_id=task_id,
+            max_steps=5,
+            solved=False,
+        )
+        return APIObservation(
+            task_id=task_id,
+            task_description=self._current_task["description"],
+            broken_request=self._current_task["broken_request"],
+            last_status_code=0,
+            last_response_headers={},
+            last_response_body="",
+            step_feedback="Episode started. Read the task description and fix the broken request.",
+            current_score=0.0,
+            attempt=0,
+            reward=0.0,
+            done=False,
+        )
+
+    def step(self, action: APIAction, **kwargs) -> APIObservation:
+        if self._current_task is None:
+            self.reset(task_id="easy")
+
+        self._state.step_count += 1
+        task = self._current_task
+
+        try:
+            with httpx.Client(base_url=MOCK_BASE, timeout=5.0) as http:
+                resp = http.request(
+                    method=action.method.upper(),
+                    url=action.url,
+                    headers=action.headers,
+                    json=action.body if action.body else None,
+                    params=action.query_params,
+                )
+            status = resp.status_code
+            resp_headers = dict(resp.headers)
+            resp_body = resp.text
+        except Exception as e:
+            status = 0
+            resp_headers = {}
+            resp_body = f"Request error: {str(e)}"
+
+        reward = GRADER.grade(
+            response_status=status,
+            response_body=resp_body,
+            expected_status=task["expected_status"],
+            expected_schema=task["expected_schema"],
+            attempt=self._state.step_count,
+            max_steps=self._state.max_steps,
+        )
+
+        feedback = GRADER.get_feedback(status, task["expected_status"])
+        solved = status == task["expected_status"] and reward >= 0.8
+        self._state.solved = solved
+        done = solved or self._state.step_count >= self._state.max_steps
+
+        return APIObservation(
+            task_id=self._state.task_id,
+            task_description=task["description"],
+            broken_request=task["broken_request"],
+            last_status_code=status,
+            last_response_headers=resp_headers,
+            last_response_body=resp_body,
+            step_feedback=feedback,
+            current_score=reward,
+            attempt=self._state.step_count,
+            reward=reward,
+            done=done,
+        )
+
+    @property
+    def state(self) -> APIState:
+        return self._state

server/app.py

@@ -0,0 +1,16 @@
+from fastapi import FastAPI
+from openenv.core.env_server import create_app
+
+from models import APIAction, APIObservation
+from server.api_debug_environment import APIDebugEnvironment
+from server.mock_api import router as mock_router
+
+# Pass the CLASS not an instance
+app = create_app(APIDebugEnvironment, APIAction, APIObservation, env_name="api_debug_env")
+
+app.include_router(mock_router)
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok", "environment": "api-debug-env"}

server/mock_api.py

@@ -0,0 +1,111 @@
+import time
+from fastapi import APIRouter, Header, HTTPException, Request, Query
+from pydantic import BaseModel
+from typing import Optional
+
+router = APIRouter(prefix="/mock_api", tags=["mock"])
+
+_issued_tokens = set()
+_request_log = {}
+
+LOG_PAGES = {
+    None: {"items": list(range(10)), "next_cursor": "cur_abc", "has_more": True},
+    "cur_abc": {"items": list(range(10, 20)), "next_cursor": "cur_def", "has_more": True},
+    "cur_def": {"items": list(range(20, 25)), "next_cursor": None, "has_more": False},
+}
+
+
+class TokenRequest(BaseModel):
+    client_id: str
+    client_secret: str
+
+@router.post("/auth/token")
+async def get_token(body: TokenRequest):
+    if body.client_id == "abc" and body.client_secret == "xyz":
+        token = f"tok_{int(time.time())}"
+        _issued_tokens.add(token)
+        return {"access_token": token, "expires_in": 60}
+    raise HTTPException(status_code=401, detail="Invalid client credentials")
+
+
+@router.get("/users")
+async def get_users(authorization: Optional[str] = Header(default=None)):
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Authorization header missing or malformed")
+    token = authorization.split(" ")[1]
+    if token not in _issued_tokens and token != "demo_token_123":
+        raise HTTPException(status_code=401, detail="Invalid token")
+    return {"users": [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]}
+
+
+@router.post("/items")
+async def create_item(request: Request):
+    ct = request.headers.get("content-type", "")
+    if "application/json" not in ct:
+        raise HTTPException(status_code=415, detail="Content-Type must be application/json")
+    body = await request.json()
+    if "name" not in body:
+        raise HTTPException(status_code=422, detail=[{"loc": ["body", "name"], "msg": "field required"}])
+    return {"item_id": 42, "name": body["name"], "created": True}
+
+
+@router.get("/search")
+async def search(q: Optional[str] = Query(default=None)):
+    if not q:
+        raise HTTPException(status_code=422, detail=[{"loc": ["query", "q"], "msg": "field required"}])
+    return {"results": [{"title": f"Result for {q}", "score": 0.95}], "total": 1}
+
+
+class OrderBody(BaseModel):
+    product_id: int
+    qty: int
+
+
+@router.post("/orders")
+async def create_order(order: OrderBody):
+    return {"order_id": 999, "product_id": order.product_id, "qty": order.qty, "status": "confirmed"}
+
+
+class AddressModel(BaseModel):
+    street: str
+    city: str
+
+
+class ProfileBody(BaseModel):
+    name: str
+    address: AddressModel
+
+
+@router.post("/profile")
+async def update_profile(profile: ProfileBody):
+    return {"name": profile.name, "address": profile.address.model_dump(), "updated": True}
+
+
+@router.get("/protected")
+async def protected(authorization: Optional[str] = Header(default=None)):
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="Authorization header missing")
+    token = authorization.split(" ")[1]
+    if token not in _issued_tokens:
+        raise HTTPException(status_code=401, detail="Invalid or expired token")
+    return {"data": "secret_payload", "accessed_at": int(time.time())}
+
+
+@router.get("/rate_limited")
+async def rate_limited(request: Request, x_retry_after: Optional[str] = Header(default=None)):
+    client_id = request.client.host if request.client else "default"
+    now = time.time()
+    window = [t for t in _request_log.get(client_id, []) if now - t < 5]
+    if len(window) >= 3 and not x_retry_after:
+        _request_log[client_id] = window
+        raise HTTPException(status_code=429, detail="Rate limit exceeded", headers={"Retry-After": "2"})
+    window.append(now)
+    _request_log[client_id] = window
+    return {"data": "rate_limited_resource", "requests_in_window": len(window)}
+
+
+@router.get("/logs")
+async def get_logs(cursor: Optional[str] = Query(default=None)):
+    if cursor not in LOG_PAGES:
+        raise HTTPException(status_code=400, detail=f"Invalid cursor: {cursor}")
+    return LOG_PAGES[cursor]

server/requirements.txt

@@ -0,0 +1,7 @@
+openenv-core>=0.2.3
+fastapi>=0.104.0
+uvicorn>=0.24.0
+pydantic>=2.0.0
+httpx>=0.27.0
+python-dotenv>=1.0.0
+openai>=1.0.0

step.json

@@ -0,0 +1 @@
+{"action": {"method":"GET","url":"/mock_api/users","headers":{"Authorization":"Bearer demo_token_123"},"body":null,"query_params":{}}}

tasks/__init__.py

@@ -0,0 +1 @@
+# empty

tasks/easy.py

@@ -0,0 +1,41 @@
+EASY_TASKS = [
+    {
+        "id": "easy_auth",
+        "description": "The request is missing an Authorization header. The API requires: Authorization: Bearer demo_token_123. Fix the request to GET /mock_api/users successfully.",
+        "broken_request": {
+            "method": "GET",
+            "url": "/mock_api/users",
+            "headers": {},
+            "body": None,
+            "query_params": {},
+        },
+        "expected_status": 200,
+        "expected_schema": {"users": []},
+    },
+    {
+        "id": "easy_content_type",
+        "description": "The request uses Content-Type: text/plain but the API requires application/json. Fix the header and send body with a name field to POST /mock_api/items.",
+        "broken_request": {
+            "method": "POST",
+            "url": "/mock_api/items",
+            "headers": {"Content-Type": "text/plain"},
+            "body": None,
+            "query_params": {},
+        },
+        "expected_status": 200,
+        "expected_schema": {"item_id": 0, "name": "", "created": True},
+    },
+    {
+        "id": "easy_query_param",
+        "description": "The search endpoint requires a query parameter q. The request omits it. Add q=python to the query params for GET /mock_api/search.",
+        "broken_request": {
+            "method": "GET",
+            "url": "/mock_api/search",
+            "headers": {},
+            "body": None,
+            "query_params": {},
+        },
+        "expected_status": 200,
+        "expected_schema": {"results": [], "total": 0},
+    },
+]

tasks/hard.py

@@ -0,0 +1,41 @@
+HARD_TASKS = [
+    {
+        "id": "hard_token_exchange",
+        "description": "The protected endpoint needs a fresh token. First POST to /mock_api/auth/token with body client_id abc and client_secret xyz to get an access_token. Then use it as Authorization: Bearer <token> to GET /mock_api/protected. The token in the broken request is expired.",
+        "broken_request": {
+            "method": "GET",
+            "url": "/mock_api/protected",
+            "headers": {"Authorization": "Bearer stale_token_000"},
+            "body": None,
+            "query_params": {},
+        },
+        "expected_status": 200,
+        "expected_schema": {"data": ""},
+    },
+    {
+        "id": "hard_rate_limit",
+        "description": "The rate_limited endpoint returns 429 if you send more than 3 requests without the X-Retry-After header. After receiving a 429 include header X-Retry-After with value 2.",
+        "broken_request": {
+            "method": "GET",
+            "url": "/mock_api/rate_limited",
+            "headers": {},
+            "body": None,
+            "query_params": {},
+        },
+        "expected_status": 200,
+        "expected_schema": {"data": ""},
+    },
+    {
+        "id": "hard_pagination",
+        "description": "GET /mock_api/logs returns only the first page with a next_cursor field. Follow the cursor chain by passing cursor as a query param until has_more is false.",
+        "broken_request": {
+            "method": "GET",
+            "url": "/mock_api/logs",
+            "headers": {},
+            "body": None,
+            "query_params": {},
+        },
+        "expected_status": 200,
+        "expected_schema": {"items": [], "has_more": False},
+    },
+]

tasks/medium.py

@@ -0,0 +1,41 @@
+MEDIUM_TASKS = [
+    {
+        "id": "medium_wrong_method",
+        "description": "Creating an order requires POST not GET. Fix the HTTP method and send body with product_id 5 and qty 2 to /mock_api/orders.",
+        "broken_request": {
+            "method": "GET",
+            "url": "/mock_api/orders",
+            "headers": {"Content-Type": "application/json"},
+            "body": {"product_id": 5, "qty": 2},
+            "query_params": {},
+        },
+        "expected_status": 200,
+        "expected_schema": {"order_id": 0, "status": ""},
+    },
+    {
+        "id": "medium_type_mismatch",
+        "description": "The API expects product_id as an integer but the request sends the string five. Fix the type to the integer 5 in the body.",
+        "broken_request": {
+            "method": "POST",
+            "url": "/mock_api/orders",
+            "headers": {"Content-Type": "application/json"},
+            "body": {"product_id": "five", "qty": 2},
+            "query_params": {},
+        },
+        "expected_status": 200,
+        "expected_schema": {"order_id": 0, "product_id": 0},
+    },
+    {
+        "id": "medium_nested_field",
+        "description": "The profile endpoint expects address to be a dict like street and city keys, not a plain string. Fix the body structure.",
+        "broken_request": {
+            "method": "POST",
+            "url": "/mock_api/profile",
+            "headers": {"Content-Type": "application/json"},
+            "body": {"name": "Alice", "address": "123 Main St"},
+            "query_params": {},
+        },
+        "expected_status": 200,
+        "expected_schema": {"name": "", "address": {}, "updated": True},
+    },
+]

tasks/registry.py

@@ -0,0 +1,9 @@
+from tasks.easy import EASY_TASKS
+from tasks.medium import MEDIUM_TASKS
+from tasks.hard import HARD_TASKS
+
+TASK_REGISTRY = {
+    "easy": EASY_TASKS,
+    "medium": MEDIUM_TASKS,
+    "hard": HARD_TASKS,
+}

test_imports.py

@@ -0,0 +1,13 @@
+try:
+    from models import APIAction, APIObservation, APIState
+    print('models OK')
+    from client import APIDebugEnv
+    print('client OK')
+    from tasks.registry import TASK_REGISTRY
+    print('tasks OK')
+    from graders.grader import APIGrader
+    print('grader OK')
+    print('ALL IMPORTS PASS')
+except Exception as e:
+    import traceback
+    traceback.print_exc()

test_server.py

@@ -0,0 +1,20 @@
+from fastapi.testclient import TestClient
+from server.app import app
+
+client = TestClient(app)
+
+def test_health():
+    response = client.get("/health")
+    assert response.status_code == 200
+    print("health OK")
+
+def test_reset():
+    response = client.post("/reset", json={"task_id": "easy"})
+    assert response.status_code == 200
+    assert "task_description" in response.json()
+    print("easy reset OK")
+
+if __name__ == "__main__":
+    test_health()
+    test_reset()
+    print("All tests passed.")