fix:minor

README.md

@@ -3,7 +3,8 @@ title: Code_man
 emoji: "🚀"
 colorFrom: blue
 colorTo: purple
-sdk: gradio
+sdk: docker
+app_port: 7860
 app_file: app.py
 pinned: false
 ---

app.py

@@ -3,12 +3,11 @@
 import os
 import sys
 import gradio as gr
-import json
 from typing import Dict, Any, Optional, List
 import logging
 
 from fastapi import Body, FastAPI
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 # Add current directory to Python path
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
@@ -341,233 +340,212 @@ def update_ui():
             gr.update(visible=True)
         )
 
-# Create Gradio interface
+# OpenEnv / TRL-style HTTP API — register routes on FastAPI before mounting Gradio at "/".
+
+
+class OpenEnvResetRequest(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    seed: Optional[int] = None
+    episode_id: Optional[str] = None
+
+
+class OpenEnvResetResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    observation: Dict[str, Any] = Field(default_factory=dict)
+    reward: float = 0.0
+    done: bool = False
+
+
+class OpenEnvStepRequest(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    action: Dict[str, Any]
+    timeout_s: Optional[float] = None
+    request_id: Optional[str] = None
+
+
+class OpenEnvStepResponse(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    observation: Dict[str, Any] = Field(default_factory=dict)
+    reward: Optional[float] = None
+    done: bool = False
+
+
+app = FastAPI(title="CodeGuardian OpenEnv")
+
+
+@app.post("/reset", response_model=OpenEnvResetResponse)
+async def openenv_reset(
+    _body: OpenEnvResetRequest = Body(default_factory=OpenEnvResetRequest),
+) -> OpenEnvResetResponse:
+    """OpenEnv reset check: body is always observation {}, reward 0.0, done false; env still resets."""
+    try:
+        obs = space.env.reset()
+        space.current_obs = obs
+        logger.info("OpenEnv POST /reset ok (task_id=%s)", getattr(obs, "task_id", None))
+    except Exception as e:
+        logger.error("OpenEnv POST /reset env.reset failed: %s", e, exc_info=True)
+    return OpenEnvResetResponse(
+        observation={},
+        reward=0.0,
+        done=False,
+    )
+
+
+@app.post("/step", response_model=OpenEnvStepResponse)
+async def openenv_step(request: OpenEnvStepRequest) -> OpenEnvStepResponse:
+    action = Action.model_validate(request.action)
+    next_obs, reward_obj, done = space.env.step(action)
+    space.current_obs = next_obs
+    obs_dict = next_obs.model_dump() if next_obs is not None else {}
+    return OpenEnvStepResponse(
+        observation=obs_dict,
+        reward=float(reward_obj.value),
+        done=done,
+    )
+
+
+@app.get("/state")
+async def openenv_state() -> Dict[str, Any]:
+    return space.env.state()
+
+
+# Gradio UI — built after API routes; mounted last so /reset, /step, /state stay reachable.
 with gr.Blocks(title="CodeGuardian Environment - RL Enhanced") as demo:
     gr.Markdown("# 🤖 CodeGuardian Environment - RL Enhanced")
     gr.Markdown("Test your AI agent on code review tasks: detect issues, assess risks, and suggest fixes with reinforcement learning.")
-    
+
     with gr.Row():
         reset_btn = gr.Button("🔄 Reset Environment", variant="primary")
         baseline_btn = gr.Button("📊 Run Baseline", variant="secondary")
         episode_btn = gr.Button("🎯 Run Episode", variant="secondary")
-        
+
     with gr.Row():
         perf_btn = gr.Button("📈 Show Performance", variant="secondary")
         plot_btn = gr.Button("📊 Show Progress Plot", variant="secondary")
-    
+
     obs_display = gr.Markdown("Click 'Reset Environment' to start")
-    
-    # VISUAL PERFORMANCE COMPARISON (NEW)
+
     with gr.Group(visible=True) as perf_group:
         gr.Markdown("## 📊 Performance Comparison")
         performance_display = gr.Markdown("Run baseline and episodes to see performance comparison.")
-    
-    # EPISODE PROGRESSION PLOT (NEW)
+
     with gr.Group(visible=True) as plot_group:
         gr.Markdown("## 📈 Episode Progression")
         progress_plot = gr.Plot(label="Score Progression")
-    
+
     with gr.Group(visible=False) as action_group:
         gr.Markdown("## Take Action")
-        
+
         with gr.Row():
             with gr.Column():
                 action_type = gr.Radio(
                     choices=["detect", "risk", "fix"],
                     label="Action Type",
-                    value="detect"
+                    value="detect",
                 )
-                
+
                 with gr.Group(visible=True) as detect_group:
                     detected_issues = gr.Textbox(
                         label="Detected Issues (comma-separated)",
-                        placeholder="e.g., wrong operator, security issue, performance problem"
+                        placeholder="e.g., wrong operator, security issue, performance problem",
                     )
-                
+
                 with gr.Group(visible=False) as risk_group:
                     risk_level = gr.Radio(
                         choices=["low", "medium", "high"],
                         label="Risk Level",
-                        value="low"
+                        value="low",
                     )
-                
+
                 with gr.Group(visible=False) as fix_group:
                     suggested_fix = gr.Textbox(
                         label="Suggested Fix",
                         lines=3,
-                        placeholder="Describe or provide the fix..."
+                        placeholder="Describe or provide the fix...",
                     )
-            
+
             with gr.Column():
                 step_btn = gr.Button("⚡ Execute Step", variant="primary")
                 feedback = gr.Textbox(label="📝 Feedback", interactive=False, lines=2)
                 reward = gr.Number(label="🏆 Reward", interactive=False)
-                
-                # Enhanced reward display
+
                 reward_breakdown = gr.Textbox(label="📊 Reward Breakdown", interactive=False, lines=1)
                 step_details = gr.Markdown("", label="Step Details")
-    
-    # Episode results display
+
     episode_results = gr.Markdown("", visible=False, label="Episode Results")
-    
-    # Event handlers
+
     reset_btn.click(
         reset_interface,
-        outputs=obs_display
+        outputs=obs_display,
     ).then(
         update_ui,
-        outputs=[reset_btn, baseline_btn, episode_btn, perf_btn, plot_btn, action_group, detect_group, risk_group, fix_group]
+        outputs=[reset_btn, baseline_btn, episode_btn, perf_btn, plot_btn, action_group, detect_group, risk_group, fix_group],
     )
-    
+
     baseline_btn.click(
         run_baseline_interface,
-        outputs=performance_display
+        outputs=performance_display,
     ).then(
         lambda: gr.update(visible=True),
-        outputs=perf_group
+        outputs=perf_group,
     )
-    
+
     episode_btn.click(
         run_episode_interface,
-        outputs=episode_results
+        outputs=episode_results,
     ).then(
         lambda: gr.update(visible=True),
-        outputs=episode_results
+        outputs=episode_results,
     ).then(
         get_plot_interface,
-        outputs=progress_plot
+        outputs=progress_plot,
     ).then(
         lambda: gr.update(visible=True),
-        outputs=plot_group
+        outputs=plot_group,
     )
-    
+
     perf_btn.click(
         get_performance_interface,
-        outputs=performance_display
+        outputs=performance_display,
     ).then(
         lambda: gr.update(visible=True),
-        outputs=perf_group
+        outputs=perf_group,
     )
-    
+
     plot_btn.click(
         get_plot_interface,
-        outputs=progress_plot
+        outputs=progress_plot,
     ).then(
         lambda: gr.update(visible=True),
-        outputs=plot_group
+        outputs=plot_group,
     )
-    
+
     def toggle_action_inputs(action):
-        """Show/hide inputs based on action type."""
         return (
             gr.update(visible=(action == "detect")),
             gr.update(visible=(action == "risk")),
-            gr.update(visible=(action == "fix"))
+            gr.update(visible=(action == "fix")),
         )
-    
+
     action_type.change(
         toggle_action_inputs,
         inputs=action_type,
-        outputs=[detect_group, risk_group, fix_group]
+        outputs=[detect_group, risk_group, fix_group],
     )
-    
+
     step_btn.click(
         step_interface,
         inputs=[action_type, detected_issues, risk_level, suggested_fix],
-        outputs=[obs_display, feedback, reward, reward_breakdown, step_details]
+        outputs=[obs_display, feedback, reward, reward_breakdown, step_details],
     ).then(
         update_ui,
-        outputs=[reset_btn, baseline_btn, episode_btn, perf_btn, plot_btn, action_group, detect_group, risk_group, fix_group]
-    )
-
-# OpenEnv / TRL-style HTTP API (POST /reset, etc.) for automated Space checks.
-# Gradio alone does not expose these routes and returns 405 Method Not Allowed.
-
-
-class OpenEnvResetRequest(BaseModel):
-    model_config = ConfigDict(extra="allow")
-
-    seed: Optional[int] = None
-    episode_id: Optional[str] = None
-
-
-class OpenEnvResetResponse(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    observation: Dict[str, Any]
-    reward: float = 0
-    done: bool = False
-
-
-class OpenEnvStepRequest(BaseModel):
-    model_config = ConfigDict(extra="allow")
-
-    action: Dict[str, Any]
-    timeout_s: Optional[float] = None
-    request_id: Optional[str] = None
-
-
-class OpenEnvStepResponse(BaseModel):
-    model_config = ConfigDict(extra="forbid")
-
-    observation: Dict[str, Any]
-    reward: Optional[float] = None
-    done: bool = False
-
-
-app = FastAPI(title="CodeGuardian OpenEnv")
-
-
-def _empty_openenv_observation() -> Dict[str, Any]:
-    return Observation(
-        code="",
-        intent="",
-        constraints=[],
-        task_id="reset_error",
-        difficulty="easy",
-        step_index=0,
-    ).model_dump()
-
-
-@app.post("/reset", response_model=OpenEnvResetResponse)
-async def openenv_reset(
-    _body: OpenEnvResetRequest = Body(default_factory=OpenEnvResetRequest),
-) -> OpenEnvResetResponse:
-    try:
-        obs = space.env.reset()
-        space.current_obs = obs
-        return OpenEnvResetResponse(
-            observation=obs.model_dump(),
-            reward=0.0,
-            done=False,
-        )
-    except Exception as e:
-        logger.error("OpenEnv POST /reset failed: %s", e, exc_info=True)
-        return OpenEnvResetResponse(
-            observation=_empty_openenv_observation(),
-            reward=0.0,
-            done=False,
-        )
-
-
-@app.post("/step", response_model=OpenEnvStepResponse)
-async def openenv_step(request: OpenEnvStepRequest) -> OpenEnvStepResponse:
-    action = Action.model_validate(request.action)
-    next_obs, reward_obj, done = space.env.step(action)
-    space.current_obs = next_obs
-    obs_dict = next_obs.model_dump() if next_obs is not None else {}
-    return OpenEnvStepResponse(
-        observation=obs_dict,
-        reward=float(reward_obj.value),
-        done=done,
+        outputs=[reset_btn, baseline_btn, episode_btn, perf_btn, plot_btn, action_group, detect_group, risk_group, fix_group],
     )
 
-
-@app.get("/state")
-async def openenv_state() -> Dict[str, Any]:
-    return space.env.state()
-
-
 demo.queue()
 app = gr.mount_gradio_app(app, demo, path="/")
 

inference.py

@@ -26,6 +26,85 @@ DEFAULT_MODEL_NAME = "meta-llama/Meta-Llama-3-8B-Instruct"
 HF_FALLBACK_MODEL = "mistralai/Mistral-7B-Instruct-v0.2"
 
 
+def _hf_auth_tokens() -> Optional[str]:
+    return os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+
+
+def _openai_auth_tokens() -> Optional[str]:
+    return os.getenv("OPENAI_API_KEY") or os.getenv("API_KEY")
+
+
+def _looks_like_huggingface_endpoint(url: str) -> bool:
+    u = (url or "").lower()
+    return any(x in u for x in ("huggingface", "hf.co", "router.huggingface"))
+
+
+def _looks_like_openai_endpoint(url: str) -> bool:
+    return "openai.com" in (url or "").lower()
+
+
+def _looks_like_hf_hub_model(model: str) -> bool:
+    """Hugging Face router / Inference typically uses org/model ids."""
+    return "/" in (model or "").strip()
+
+
+def _looks_like_openai_model(model: str) -> bool:
+    m = (model or "").strip().lower()
+    if not m or "/" in m:
+        return False
+    prefixes = (
+        "gpt-",
+        "o1",
+        "o3",
+        "o4",
+        "ft:",
+        "davinci",
+        "text-embedding",
+        "chatgpt-",
+    )
+    return any(m.startswith(p) for p in prefixes)
+
+
+def _resolve_api_key(api_base_url: str, model_name: str) -> str:
+    """
+    Pick API key for an OpenAI-compatible client: Hugging Face token and/or OpenAI key,
+    ordered from URL + model hints, with 'or' fallbacks so either stack can work.
+    """
+    hf_key = _hf_auth_tokens()
+    oai_key = _openai_auth_tokens()
+
+    url_hf = _looks_like_huggingface_endpoint(api_base_url)
+    url_oai = _looks_like_openai_endpoint(api_base_url)
+    model_hf = _looks_like_hf_hub_model(model_name)
+    model_oai = _looks_like_openai_model(model_name)
+
+    prefer_hf = url_hf or model_hf
+    prefer_oai = url_oai or model_oai
+
+    key: Optional[str] = None
+    if prefer_hf and not prefer_oai:
+        key = hf_key or oai_key
+    elif prefer_oai and not prefer_hf:
+        key = oai_key or hf_key
+    elif prefer_hf and prefer_oai:
+        if url_hf and not url_oai:
+            key = hf_key or oai_key
+        elif url_oai and not url_hf:
+            key = oai_key or hf_key
+        else:
+            key = hf_key or oai_key
+    else:
+        key = hf_key or oai_key
+
+    if not key:
+        raise ValueError(
+            "Set authentication for your provider: "
+            "(HF_TOKEN or HUGGINGFACEHUB_API_TOKEN) for Hugging Face, "
+            "or (OPENAI_API_KEY or API_KEY) for OpenAI"
+        )
+    return key
+
+
 def _fallback_llm_json_string(reason: str = "LLM unavailable") -> str:
     return json.dumps(
         {
@@ -46,17 +125,29 @@ def setup_openai_client() -> tuple[OpenAI, str]:
 
     api_base_url = os.getenv("API_BASE_URL", DEFAULT_API_BASE_URL)
     model_name = os.getenv("MODEL_NAME", DEFAULT_MODEL_NAME)
-    hf_token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    api_key = _resolve_api_key(api_base_url, model_name)
+
+    hf_key = _hf_auth_tokens()
+    oai_key = _openai_auth_tokens()
+    if api_key == hf_key and hf_key:
+        auth_label = "Hugging Face token (HF_TOKEN / HUGGINGFACEHUB_API_TOKEN)"
+    elif api_key == oai_key and oai_key:
+        auth_label = "OpenAI key (OPENAI_API_KEY / API_KEY)"
+    else:
+        auth_label = "resolved API key"
 
     print(f"DEBUG: API_BASE_URL={api_base_url}")
     print(f"DEBUG: MODEL_NAME={model_name}")
-    logger.info("HF OpenAI-compatible client: API_BASE_URL=%s MODEL_NAME=%s", api_base_url, model_name)
-
-    if not hf_token:
-        raise ValueError("Set HF_TOKEN or HUGGINGFACEHUB_API_TOKEN for Hugging Face API access")
+    print(f"DEBUG: auth={auth_label}")
+    logger.info(
+        "OpenAI-compatible client: API_BASE_URL=%s MODEL_NAME=%s auth=%s",
+        api_base_url,
+        model_name,
+        auth_label,
+    )
 
     client = OpenAI(
-        api_key=hf_token,
+        api_key=api_key,
         base_url=api_base_url,
     )
 

requirements.txt

@@ -1,10 +1,13 @@
-pydantic>=2.0.0
+# Hugging Face Space / OpenEnv server (required)
+fastapi>=0.110.0
+uvicorn[standard]>=0.27.0
+gradio>=4.0.0
 openai>=1.0.0
+
+pydantic>=2.0.0
 gymnasium>=0.28.0
 numpy>=1.24.0
 python-dotenv>=1.0.0
 flask>=3.0.0
-fastapi>=0.110.0
-uvicorn[standard]>=0.27.0
-gradio>=4.0.0
-plotly
+plotly
+pandas