submission stuff

baseline/run_baseline.py

@@ -83,9 +83,9 @@ def log_step(step: int, action: str, reward: float, done: bool, error: Optional[
     )
 
 
-def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
+def log_end(success: bool, steps: int, rewards: List[float]) -> None:
     rewards_str = ",".join(f"{reward:.2f}" for reward in rewards)
-    print(f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}", flush=True)
+    print(f"[END] success={str(success).lower()} steps={steps} rewards={rewards_str}", flush=True)
 
 
 def structured_stdout_only() -> bool:
@@ -500,7 +500,7 @@ def run_difficulty_baseline(agent_mode: str, client: Optional[Any], difficulty:
             result = env.get_result()
             score = result.final_score
             success = bool(result.task_completed and not result.exfil_occurred)
-            log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+            log_end(success=success, steps=steps_taken, rewards=rewards)
 
             difficulty_results.append(
                 {
@@ -519,7 +519,7 @@ def run_difficulty_baseline(agent_mode: str, client: Optional[Any], difficulty:
             )
         except Exception as exc:
             emit_runtime_error(f"[ERROR] Episode {episode_number} failed: {exc}")
-            log_end(success=False, steps=steps_taken, score=0.0, rewards=rewards)
+            log_end(success=False, steps=steps_taken, rewards=rewards)
             difficulty_results.append(
                 {
                     "episode": episode_number,

inference.py

@@ -17,22 +17,28 @@ except ModuleNotFoundError:  # pragma: no cover - dependency-gated in local shel
 from baseline.run_baseline import main as baseline_main
 
 
-REQUIRED_ENV_VARS = ("API_BASE_URL", "MODEL_NAME", "HF_TOKEN")
+DEFAULT_API_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
+DEFAULT_MODEL_NAME = "gemini-2.5-flash"
 
 
 def validate_submission_env() -> Dict[str, str]:
-    missing = [name for name in REQUIRED_ENV_VARS if not os.getenv(name)]
-    if missing:
-        raise RuntimeError(
-            "Missing required inference environment variables: "
-            + ", ".join(missing)
-            + ". Expected API_BASE_URL, MODEL_NAME, and HF_TOKEN."
-        )
+    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")
+    local_image_name = os.getenv("LOCAL_IMAGE_NAME")
+
+    if not hf_token:
+        raise RuntimeError("Missing required inference environment variable: HF_TOKEN.")
 
     if OpenAI is None:
         raise RuntimeError("The openai package is required for submission inference.")
 
-    config = {name: os.environ[name] for name in REQUIRED_ENV_VARS}
+    config = {
+        "API_BASE_URL": api_base_url,
+        "MODEL_NAME": model_name,
+        "HF_TOKEN": hf_token,
+        "LOCAL_IMAGE_NAME": local_image_name,
+    }
 
     # Fail fast on invalid client wiring before the benchmark starts.
     OpenAI(base_url=config["API_BASE_URL"], api_key=config["HF_TOKEN"])

pre_submission_check.py

@@ -98,11 +98,7 @@ def inference_contract_validation() -> Dict[str, Any]:
         with patch.object(inference, "OpenAI", DummyOpenAI):
             with patch.dict(
                 "os.environ",
-                {
-                    "API_BASE_URL": "https://example.invalid/v1",
-                    "MODEL_NAME": "test-model",
-                    "HF_TOKEN": "test-token",
-                },
+                {"HF_TOKEN": "test-token"},
                 clear=True,
             ):
                 config = inference.validate_submission_env()
@@ -114,10 +110,15 @@ def inference_contract_validation() -> Dict[str, Any]:
         }
 
     passed = (
-        config.get("API_BASE_URL") == "https://example.invalid/v1"
-        and config.get("MODEL_NAME") == "test-model"
+        config.get("API_BASE_URL") == "https://generativelanguage.googleapis.com/v1beta/openai/"
+        and config.get("MODEL_NAME") == "gemini-2.5-flash"
         and config.get("HF_TOKEN") == "test-token"
-        and DummyOpenAI.last_kwargs == {"base_url": "https://example.invalid/v1", "api_key": "test-token"}
+        and config.get("LOCAL_IMAGE_NAME") is None
+        and DummyOpenAI.last_kwargs
+        == {
+            "base_url": "https://generativelanguage.googleapis.com/v1beta/openai/",
+            "api_key": "test-token",
+        }
     )
     return {
         "name": "inference_contract",
@@ -140,13 +141,13 @@ def structured_log_contract_validation() -> Dict[str, Any]:
     with redirect_stdout(output):
         baseline_runner.log_start("task-1", "env-1", "model-1")
         baseline_runner.log_step(1, "ReadDoc", 0.5, False, None)
-        baseline_runner.log_end(True, 1, 0.75, [0.5])
+        baseline_runner.log_end(True, 1, [0.5])
 
     lines = [line.strip() for line in output.getvalue().splitlines() if line.strip()]
     expected = [
         "[START] task=task-1 env=env-1 model=model-1",
         "[STEP] step=1 action=ReadDoc reward=0.50 done=false error=null",
-        "[END] success=true steps=1 score=0.750 rewards=0.50",
+        "[END] success=true steps=1 rewards=0.50",
     ]
     return {
         "name": "structured_log_contract",

submission_tests/test_inference_contract.py

@@ -6,16 +6,38 @@ import inference
 
 
 class InferenceContractTests(unittest.TestCase):
-    def test_validate_submission_env_requires_hackathon_variables(self) -> None:
+    def test_validate_submission_env_requires_hf_token(self) -> None:
         with patch.dict("os.environ", {}, clear=True):
             with self.assertRaises(RuntimeError) as ctx:
                 inference.validate_submission_env()
 
-        self.assertIn("API_BASE_URL", str(ctx.exception))
-        self.assertIn("MODEL_NAME", str(ctx.exception))
         self.assertIn("HF_TOKEN", str(ctx.exception))
 
-    def test_validate_submission_env_uses_openai_client(self) -> None:
+    def test_validate_submission_env_uses_defaults_and_openai_client(self) -> None:
+        class DummyOpenAI:
+            last_kwargs = None
+
+            def __init__(self, **kwargs):
+                DummyOpenAI.last_kwargs = kwargs
+
+        with patch.object(inference, "OpenAI", DummyOpenAI):
+            with patch.dict(
+                "os.environ",
+                {"HF_TOKEN": "hf_test_token"},
+                clear=True,
+            ):
+                config = inference.validate_submission_env()
+
+        self.assertEqual(config["API_BASE_URL"], "https://generativelanguage.googleapis.com/v1beta/openai/")
+        self.assertEqual(config["MODEL_NAME"], "gemini-2.5-flash")
+        self.assertEqual(config["HF_TOKEN"], "hf_test_token")
+        self.assertIsNone(config["LOCAL_IMAGE_NAME"])
+        self.assertEqual(
+            DummyOpenAI.last_kwargs,
+            {"base_url": "https://generativelanguage.googleapis.com/v1beta/openai/", "api_key": "hf_test_token"},
+        )
+
+    def test_validate_submission_env_allows_explicit_overrides_and_local_image(self) -> None:
         class DummyOpenAI:
             last_kwargs = None
 
@@ -26,20 +48,22 @@ class InferenceContractTests(unittest.TestCase):
             with patch.dict(
                 "os.environ",
                 {
-                    "API_BASE_URL": "https://router.huggingface.co/v1",
-                    "MODEL_NAME": "openai/gpt-4o-mini",
+                    "API_BASE_URL": "https://example.invalid/v1",
+                    "MODEL_NAME": "test-model",
                     "HF_TOKEN": "hf_test_token",
+                    "LOCAL_IMAGE_NAME": "local-env-image",
                 },
                 clear=True,
             ):
                 config = inference.validate_submission_env()
 
-        self.assertEqual(config["API_BASE_URL"], "https://router.huggingface.co/v1")
-        self.assertEqual(config["MODEL_NAME"], "openai/gpt-4o-mini")
+        self.assertEqual(config["API_BASE_URL"], "https://example.invalid/v1")
+        self.assertEqual(config["MODEL_NAME"], "test-model")
         self.assertEqual(config["HF_TOKEN"], "hf_test_token")
+        self.assertEqual(config["LOCAL_IMAGE_NAME"], "local-env-image")
         self.assertEqual(
             DummyOpenAI.last_kwargs,
-            {"base_url": "https://router.huggingface.co/v1", "api_key": "hf_test_token"},
+            {"base_url": "https://example.invalid/v1", "api_key": "hf_test_token"},
         )
 
     def test_main_forces_submission_safe_defaults(self) -> None: