Blame for evaluation/FireWorldBench-ICLR/scripts/run_api.py

"""Resumable cross-provider runner for a frozen FG9 subset.



The runner never reads gold. It records transport failures, schema fallbacks and

format-only re-asks separately so that provider protocol failures cannot be

mistaken for model capability failures.

"""
from __future__ import annotations

import argparse
import base64
import hashlib
import json
import os
import random
import re
import time
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

import requests


RUNNER_VERSION = "FWB-FG9-API-RUNNER-v10.1-openai-chat-wire-null-safe"
PROMPT_VERSION = "FWB-v2-independent-context-numbered-images"
SCHEMA_VERSION = "FWB-v2-single-hypothesis-or-exact-set"

CANONICAL_MODEL_ALIASES = {
    "claude-haiku-4-5": {"claude-haiku-4-5-20251001"},
}


def model_identity_matches(requested: str, reported: str | None) -> bool:
    if reported is None:
        return False
    return reported == requested or reported in CANONICAL_MODEL_ALIASES.get(requested, set())


def completed_qa_ids(rows: list[dict], provider: str, model: str) -> set[str]:
    return {
        row["qa_id"]
        for row in rows
        if row.get("status") in {"ok", "model_mismatch"}
        and (provider != "openai"
             or model_identity_matches(model, row.get("response_model")))
    }


TASK_FIELDS = {
    "L1-1": {"event_class": ["fire", "no_fire", "ventilation_disturbance", "sensor_fault"],
             "cause_region": [*[f"R{i}" for i in range(1, 9)], "global", "none"],
             "dominant_signal": ["temperature", "soot", "visibility", "flow", "none"],
             "secondary_signal": ["temperature", "soot", "visibility", "flow", "none"],
             "affected_region_count": list(range(9))},
    "L1-2": {"temperature_trend": ["up", "stable", "down"], "smoke_trend": ["up", "stable", "down"],
             "visibility_trend": ["up", "stable", "down"]},
    "L1-3": {"consistency": ["consistent", "inconsistent"],
             "first_violation_bin": ["none", "early", "middle", "late"],
             "violation_type": ["none", "reverse", "jump", "disappearance", "direction_flip", "sensor_conflict"]},
    "L2-1": {"source_region": [f"R{i}" for i in range(1, 9)],
             "stage": ["incipient", "growth", "developed", "decay"]},
    "L2-2": {"risk_region": [f"R{i}" for i in range(1, 9)],
             "risk_level": ["low", "moderate", "high", "critical"],
             "risk_driver": ["temperature", "visibility", "soot"],
             "runner_up_region": [f"R{i}" for i in range(1, 9)],
             "stability_phase": ["early", "middle", "late", "unstable"],
             "winner_switch_count_bin": ["zero", "one", "multiple"],
             "winner_support_count": [f"v{i}" for i in range(16)],
             "runner_up_support_count": [f"v{i}" for i in range(16)],
             "winner_switch_count": [f"v{i}" for i in range(16)]},
    "L2-3": {"mechanism": ["buoyant_plume", "ceiling_jet", "smoke_layer", "longitudinal_ventilation",
                             "backlayering", "extraction_dominated"],
             "flow_direction": ["vertical", "downstream", "upstream", "bidirectional", "mixed"],
             "control_regime": ["buoyancy", "ventilation", "extraction", "mixed"]},
    "L3-2": {"region": [*[f"R{i}" for i in range(1, 9)], "none"],
             "time_bin": ["none", "0_10s", "10_30s", "30_60s", "after_60s"],
             "trigger_variable": ["none", "temperature", "visibility", "soot"]},
    "L3-3": {"direction": ["A", "B", "same"],
             "magnitude_bin": ["negligible", "small", "medium", "large"],
             "earliest_affected_target": ["none", "temperature", "smoke", "visibility", "risk_region"]},
}


def load_jsonl(path: Path) -> list[dict]:
    return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]


def load_confidential_config(path: Path) -> dict[str, str]:
    values = {}
    for line in path.read_text(encoding="utf-8").splitlines():
        match = re.match(r"^([A-Z][A-Z0-9_]+)=(.+)$", line.strip())
        if match:
            values[match.group(1)] = match.group(2).strip()
    return values


def enum_value_schema(values: list[object]) -> dict:
    if values and all(isinstance(value, str) for value in values):
        value_type = "string"
    elif values and all(isinstance(value, int) and not isinstance(value, bool) for value in values):
        value_type = "integer"
    else:
        raise ValueError(f"enum values must have one supported scalar type: {values!r}")
    return {"type": value_type, "enum": values}


def enum_object(fields: dict[str, list[object]]) -> dict:
    return {
        "type": "object", "additionalProperties": False, "required": list(fields),
        "properties": {key: enum_value_schema(values) for key, values in fields.items()},
    }


def full_prediction_schema(task: str) -> dict:
    if task != "L3-1":
        return enum_object(TASK_FIELDS[task])
    trend = enum_object({"temperature_trend": ["up", "stable", "down"],
                         "smoke_trend": ["up", "stable", "down"],
                         "visibility_trend": ["up", "stable", "down"]})
    return {
        "type": "object", "additionalProperties": False, "required": ["horizons"],
        "properties": {"horizons": {
            "type": "object", "additionalProperties": False, "required": ["10s", "30s", "60s"],
            "properties": {key: trend for key in ("10s", "30s", "60s")},
        }},
    }


def schema_subset(schema: dict, fields: list[str]) -> dict:
    selected: dict = {"type": "object", "additionalProperties": False, "required": [], "properties": {}}
    for field in fields:
        source = schema
        target = selected
        for part in field.split("."):
            if source.get("type") != "object" or part not in source.get("properties", {}):
                raise KeyError(f"unknown prediction field: {field}")
            source = source["properties"][part]
            if part not in target["properties"]:
                target["required"].append(part)
                target["properties"][part] = (
                    {"type": "object", "additionalProperties": False,
                     "required": [], "properties": {}}
                    if source.get("type") == "object" else source
                )
            target = target["properties"][part]
    return selected


def prediction_schema(row: dict) -> dict:
    schema = full_prediction_schema(row["task"])
    fields = row.get("answer_fields")
    return schema_subset(schema, fields) if fields else schema


def response_schema(row: dict) -> dict:
    if row["question_type"] == "choice":
        labels = [option["label"] for option in row.get("options", [])]
        if not labels or len(labels) != len(set(labels)):
            raise ValueError(f"invalid choice labels for {row.get('qa_id', '<unknown>')}")
        return {
            "type": "object", "additionalProperties": False, "required": ["choices", "confidence"],
            "properties": {"choices": {"type": "array", "items": {"type": "string", "enum": labels},
                                        "minItems": 1 if all('hypothesis' in o for o in row['options']) else 0,
                                        "maxItems": 1 if all('hypothesis' in o for o in row['options']) else len(labels), "uniqueItems": True},
                           "confidence": {"type": "number", "minimum": 0, "maximum": 1}},
        }
    return {
        "type": "object", "additionalProperties": False,
        "required": ["conclusion", "prediction", "evidence", "mechanism", "confidence"],
        "properties": {
            "conclusion": {"type": "string"}, "prediction": prediction_schema(row),
            "evidence": {"type": "array", "items": {"type": "string"}},
            "mechanism": {"type": "string"},
            "confidence": {"type": "number", "minimum": 0, "maximum": 1},
        },
    }


def strip_paths(value: Any) -> Any:
    if isinstance(value, list):
        return [strip_paths(item) for item in value]
    if isinstance(value, dict):
        return {key: strip_paths(item) for key, item in value.items() if key not in {"path", "asset_path"}}
    return value


def asset_entries(value: Any) -> list[dict]:
    output = []
    if isinstance(value, list):
        for item in value:
            output.extend(asset_entries(item))
    elif isinstance(value, dict):
        if "path" in value or "asset_path" in value:
            output.append(value)
        for key, item in value.items():
            if key not in {"path", "asset_path"}:
                output.extend(asset_entries(item))
    return output


def resolve_asset(entry: dict, source_root: Path) -> Path:
    relative = entry.get("path", entry.get("asset_path"))
    path = source_root / str(relative)
    if not path.is_file():
        raise FileNotFoundError(path)
    return path


def prompt_text(row: dict, task_contract: str | None = None) -> str:
    material = strip_paths(row["material"])
    parts = []
    if task_contract:
        parts.extend(["Frozen task contract (shared across all items):", task_contract])
    parts.extend([f"Task: {row['task']}", row["question"],
                  "Query context:", json.dumps(row.get("query_context", {}), ensure_ascii=False),
                  "Observation metadata/data:",
                  json.dumps(material, ensure_ascii=False, separators=(",", ":"))])
    entries = asset_entries(row['material'])
    if entries:
        parts.append('Image attachment order (Image N matches image_index N):')
        for index, entry in enumerate(entries, 1):
            if entry.get('image_index', index) != index:
                raise ValueError('Image metadata order differs from attachment order')
            parts.append(f"Image {index}: " + json.dumps(strip_paths(entry), ensure_ascii=False))
    if row["question_type"] == "choice":
        parts.extend(["Candidate hypotheses:", json.dumps(row["options"], ensure_ascii=False, separators=(",", ":")),
                      ('Select exactly one complete hypothesis.' if all('hypothesis' in o for o in row['options'])
                       else 'Select every and only true claim.') + ' Return only JSON with choices (label array) and confidence (0..1).'])
    else:
        parts.append("Return only the required JSON report. Evidence must contain 1-3 concise observed facts; mechanism must explain the physical link.")
    return "\n".join(parts)


def encode_images(row: dict, source_root: Path) -> list[tuple[str, str]]:
    images = []
    for entry in asset_entries(row["material"]):
        path = resolve_asset(entry, source_root)
        mime = "image/png" if path.suffix.lower() == ".png" else "image/jpeg"
        images.append((mime, base64.b64encode(path.read_bytes()).decode("ascii")))
    return images


def extract_text(provider: str, response: dict) -> str:
    if provider in {"openai", "grok"}:
        if isinstance(response.get("output_text"), str):
            return response["output_text"]
        chunks = []
        for item in response.get("output", []):
            for content in item.get("content", []):
                if isinstance(content.get("text"), str):
                    chunks.append(content["text"])
        if chunks:
            return "\n".join(chunks)
        choices = response.get("choices", [])
        return (choices[0].get("message", {}).get("content") or "") if choices else ""
    if provider == "anthropic":
        return "\n".join(item.get("text", "") for item in response.get("content", []) if item.get("type") == "text")
    if provider == "gemini":
        candidates = response.get("candidates", [])
        if not candidates:
            return ""
        return "\n".join(part.get("text", "") for part in candidates[0].get("content", {}).get("parts", []))
    choices = response.get("choices", [])
    return (choices[0].get("message", {}).get("content") or "") if choices else ""


def usage_record(provider: str, response: dict) -> dict:
    if provider == "gemini":
        return response.get("usageMetadata", {})
    return response.get("usage", {})


def normalized_usage(provider: str, response: dict) -> dict:
    usage = usage_record(provider, response)
    if provider == "gemini":
        return {
            "input_tokens": usage.get("promptTokenCount"),
            "output_tokens": usage.get("candidatesTokenCount"),
            "cached_tokens": usage.get("cachedContentTokenCount"),
            "reasoning_tokens": usage.get("thoughtsTokenCount"),
            "total_tokens": usage.get("totalTokenCount"),
        }
    input_details = usage.get("input_tokens_details") or usage.get("prompt_tokens_details") or {}
    output_details = usage.get("output_tokens_details") or usage.get("completion_tokens_details") or {}
    return {
        "input_tokens": usage.get("input_tokens", usage.get("prompt_tokens")),
        "output_tokens": usage.get("output_tokens", usage.get("completion_tokens")),
        "cached_tokens": usage.get("cache_read_input_tokens", input_details.get("cached_tokens")),
        "reasoning_tokens": output_details.get("reasoning_tokens"),
        "total_tokens": usage.get("total_tokens"),
    }


def provider_cost(response: dict) -> dict:
    usage = response.get("usage") if isinstance(response.get("usage"), dict) else {}
    candidates = (
        (response.get("cost"), "response.cost"),
        (response.get("total_cost"), "response.total_cost"),
        (usage.get("cost"), "response.usage.cost"),
        (usage.get("total_cost"), "response.usage.total_cost"),
    )
    for value, source in candidates:
        if isinstance(value, (int, float)) and not isinstance(value, bool):
            currency = response.get("currency") or usage.get("currency")
            return {"amount": value, "currency": currency, "source": source}
    return {"amount": None, "currency": None, "source": "not_returned_by_provider"}


def response_model(provider: str, response: dict) -> str | None:
    if provider == "gemini":
        return response.get("modelVersion")
    return response.get("model")


def file_digest(path: Path) -> str:
    value = hashlib.sha256()
    with path.open("rb") as stream:
        for block in iter(lambda: stream.read(1 << 20), b""):
            value.update(block)
    return value.hexdigest()


def classify_exception(exc: Exception) -> str:
    text = str(exc).lower()
    if isinstance(exc, KeyError):
        return "tooling"
    if isinstance(exc, FileNotFoundError):
        return "capability"
    if any(term in text for term in (
        "datainspectionfailed", "data_inspection_failed", "inappropriate content",
        "content safety", "content policy", "safety filter",
    )):
        return "content_safety"
    if any(term in text for term in ("billing", "insufficient credit", "insufficient balance", "http 402")):
        return "billing"
    if "timeout" in text or isinstance(exc, requests.Timeout):
        return "timeout"
    if "proxy" in text:
        return "proxy"
    if "http 429" in text or "rate limit" in text:
        return "rate_limit"
    if re.search(r"http (?:4|5)\d\d", text):
        return "http"
    if any(term in text for term in ("connection", "transport")):
        return "transport"
    return "capability"


def write_run_manifest(path: Path, metadata: dict, records: list[dict]) -> None:
    status_counts: dict[str, int] = {}
    error_counts: dict[str, int] = {}
    usage_totals = {key: 0 for key in ("input_tokens", "output_tokens", "cached_tokens", "reasoning_tokens", "total_tokens")}
    unknown_usage = {key: 0 for key in usage_totals}
    costs = []
    for record in records:
        status = str(record.get("status", "unknown"))
        status_counts[status] = status_counts.get(status, 0) + 1
        classification = record.get("error_classification")
        if classification:
            error_counts[classification] = error_counts.get(classification, 0) + 1
        for key in usage_totals:
            value = record.get("usage_normalized", {}).get(key)
            if isinstance(value, (int, float)) and not isinstance(value, bool):
                usage_totals[key] += value
            else:
                unknown_usage[key] += 1
        cost = record.get("provider_cost", {})
        if cost.get("amount") is not None:
            costs.append(cost)
    manifest = {
        **metadata,
        "updated_at_utc": datetime.now(timezone.utc).isoformat(),
        "record_count": len(records),
        "status_counts": status_counts,
        "error_classification_counts": error_counts,
        "usage_totals": usage_totals,
        "usage_missing_record_counts": unknown_usage,
        "provider_cost_records": costs,
        "provider_cost_note": "No monetary amount is inferred when the provider response omits billing data.",
    }
    temporary = path.with_suffix(path.suffix + ".tmp")
    temporary.write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    temporary.replace(path)


def numbered_image_parts(images, wire):
    parts = []
    for index, (mime, data) in enumerate(images, 1):
        label = f"Image {index} (see corresponding observation metadata):"
        if wire == "gemini":
            parts.extend([{"text": label}, {"inlineData": {"mimeType": mime, "data": data}}])
        elif wire == "responses":
            parts.extend([{"type": "input_text", "text": label}, {"type": "input_image", "image_url": f"data:{mime};base64,{data}"}])
        elif wire == "anthropic":
            parts.extend([{"type": "text", "text": label}, {"type": "image", "source": {"type": "base64", "media_type": mime, "data": data}}])
        else:
            parts.extend([{"type": "text", "text": label}, {"type": "image_url", "image_url": {"url": f"data:{mime};base64,{data}"}}])
    return parts


def build_request(provider: str, model: str, system: str, prompt: str, images: list[tuple[str, str]],

                  schema: dict, mode: str, max_tokens: int, reasoning_effort: str,

                  wire_api: str = "responses") -> tuple[str, dict, dict]:
    if provider in {"openai", "grok"}:
        if provider == "openai" and wire_api == "chat_completions":
            content = [{"type": "text", "text": prompt}]
            content.extend(numbered_image_parts(images, "chat"))
            payload = {
                "model": model,
                "messages": [{"role": "system", "content": system}, {"role": "user", "content": content}],
                "max_tokens": max_tokens,
                "reasoning_effort": reasoning_effort,
            }
            if mode == "json_schema":
                payload["response_format"] = {
                    "type": "json_schema",
                    "json_schema": {"name": "fwb_fg9_report", "strict": True, "schema": schema},
                }
            elif mode == "json_object":
                payload["response_format"] = {"type": "json_object"}
            return "/chat/completions", {
                "Authorization": "Bearer {key}", "Content-Type": "application/json",
            }, payload
        content = [{"type": "input_text", "text": prompt}]
        content.extend(numbered_image_parts(images, "responses"))
        payload = {"model": model, "input": [{"role": "system", "content": [{"type": "input_text", "text": system}]},
                                               {"role": "user", "content": content}],
                   "max_output_tokens": max_tokens, "store": False, "reasoning": {"effort": reasoning_effort}}
        if mode == "json_schema":
            payload["text"] = {"format": {"type": "json_schema", "name": "fwb_fg9_report", "schema": schema, "strict": True}}
        elif mode == "json_object":
            payload["text"] = {"format": {"type": "json_object"}}
        path = "/responses" if provider == "grok" else "/responses"
        return path, {"Authorization": "Bearer {key}", "Content-Type": "application/json"}, payload
    if provider == "anthropic":
        content = [{"type": "text", "text": prompt}]
        content.extend(numbered_image_parts(images, "anthropic"))
        payload = {"model": model, "system": system, "messages": [{"role": "user", "content": content}],
                   "max_tokens": max_tokens, "temperature": 0}
        if mode == "json_schema":
            payload["output_config"] = {"format": {"type": "json_schema", "schema": schema}}
        return "/v1/messages", {"x-api-key": "{key}", "anthropic-version": "2023-06-01", "Content-Type": "application/json"}, payload
    if provider == "gemini":
        parts = [{"text": system + "\n\n" + prompt}]
        parts.extend(numbered_image_parts(images, "gemini"))
        generation = {"temperature": 0, "maxOutputTokens": max_tokens, "responseMimeType": "application/json"}
        if mode == "json_schema":
            generation["responseJsonSchema"] = schema
        payload = {"contents": [{"role": "user", "parts": parts}], "generationConfig": generation}
        return f"/v1beta/models/{model}:generateContent", {"x-goog-api-key": "{key}",
                                                              "Content-Type": "application/json"}, payload
    if provider == "gemini_openai_compat":
        content = [{"type": "text", "text": prompt}]
        content.extend(numbered_image_parts(images, "chat"))
        payload = {
            "model": model,
            "messages": [{"role": "system", "content": system}, {"role": "user", "content": content}],
            "temperature": 0,
            "max_tokens": max_tokens,
        }
        if mode == "json_schema":
            payload["response_format"] = {
                "type": "json_schema",
                "json_schema": {"name": "fwb_fg9_report", "strict": True, "schema": schema},
            }
        elif mode == "json_object":
            payload["response_format"] = {"type": "json_object"}
        return "/chat/completions", {"Authorization": "Bearer {key}", "Content-Type": "application/json"}, payload
    content = [{"type": "text", "text": prompt}]
    content.extend(numbered_image_parts(images, "chat"))
    payload = {"model": model, "messages": [{"role": "system", "content": system}, {"role": "user", "content": content}],
               "temperature": 0, "max_tokens": max_tokens, "enable_thinking": False}
    if mode == "json_schema":
        payload["response_format"] = {"type": "json_schema", "json_schema": {"name": "fwb_fg9_report", "strict": True, "schema": schema}}
    elif mode == "json_object":
        payload["response_format"] = {"type": "json_object"}
    return "/chat/completions", {"Authorization": "Bearer {key}", "Content-Type": "application/json"}, payload


def parse_json(text: str) -> dict | None:
    cleaned = re.sub(r"^```(?:json)?\s*|\s*```$", "", text.strip(), flags=re.IGNORECASE)
    try:
        value = json.loads(cleaned)
        return value if isinstance(value, dict) else None
    except json.JSONDecodeError:
        start, end = text.find("{"), text.rfind("}")
        if start >= 0 and end > start:
            try:
                value = json.loads(text[start:end + 1])
                return value if isinstance(value, dict) else None
            except json.JSONDecodeError:
                pass
    return None


def validation_errors(value: Any, schema: dict, path: str = "<root>") -> list[str]:
    errors: list[str] = []
    expected_type = schema.get("type")
    type_ok = {
        "object": isinstance(value, dict),
        "array": isinstance(value, list),
        "string": isinstance(value, str),
        "integer": isinstance(value, int) and not isinstance(value, bool),
        "number": isinstance(value, (int, float)) and not isinstance(value, bool),
    }.get(expected_type, True)
    if not type_ok:
        return [f"{path}: expected {expected_type}, got {type(value).__name__}"]
    if "enum" in schema and value not in schema["enum"]:
        errors.append(f"{path}: value {value!r} not in enum")
    if expected_type == "number":
        if "minimum" in schema and value < schema["minimum"]:
            errors.append(f"{path}: value below minimum")
        if "maximum" in schema and value > schema["maximum"]:
            errors.append(f"{path}: value above maximum")
    elif expected_type == "object":
        required = set(schema.get("required", []))
        missing = sorted(required - set(value))
        if missing:
            errors.append(f"{path}: missing required keys {missing}")
        properties = schema.get("properties", {})
        if schema.get("additionalProperties") is False:
            extra = sorted(set(value) - set(properties))
            if extra:
                errors.append(f"{path}: additional keys {extra}")
        for key, child_schema in properties.items():
            if key in value:
                errors.extend(validation_errors(value[key], child_schema, f"{path}.{key}"))
    elif expected_type == "array":
        if "minItems" in schema and len(value) < schema["minItems"]:
            errors.append(f"{path}: fewer than minItems")
        if "maxItems" in schema and len(value) > schema["maxItems"]:
            errors.append(f"{path}: more than maxItems")
        if schema.get("uniqueItems") and len({json.dumps(item, sort_keys=True) for item in value}) != len(value):
            errors.append(f"{path}: duplicate items")
        item_schema = schema.get("items", {})
        for index, item in enumerate(value):
            errors.extend(validation_errors(item, item_schema, f"{path}[{index}]"))
    return errors


def post_with_retry(session: requests.Session, url: str, headers: dict, payload: dict,

                    timeout: float, retries: int) -> tuple[dict, int, float]:
    started = time.perf_counter()
    last_error = None
    for attempt in range(retries + 1):
        try:
            response = session.post(url, headers=headers, json=payload, timeout=timeout)
            if response.status_code < 400:
                return response.json(), attempt, time.perf_counter() - started
            error = RuntimeError(f"HTTP {response.status_code}: {response.text[:800]}")
            if response.status_code not in {408, 409, 429, 500, 502, 503, 504}:
                raise error
            last_error = error
        except (requests.Timeout, requests.ConnectionError, ValueError) as exc:
            last_error = exc
        if attempt < retries:
            time.sleep(min(12.0, 1.5 * 2 ** attempt) + random.random() * 0.5)
    raise RuntimeError(f"transport exhausted after {retries + 1} attempts: {last_error}")


def provider_config(provider: str, values: dict[str, str]) -> tuple[str, str, str]:
    if provider == "openai":
        return values["OPENAI_BASE_URL"], values["OPENAI_API_KEY"], values["OPENAI_MODEL"]
    if provider == "grok":
        return values["GROK_BASE_URL"], values["GROK_API_KEY"], values["GROK_MODEL"]
    if provider == "anthropic":
        return values["ANTHROPIC_BASE_URL"], values["ANTHROPIC_AUTH_TOKEN"], values["ANTHROPIC_MODEL"]
    if provider == "gemini":
        return values["GOOGLE_GEMINI_BASE_URL"], values["GEMINI_API_KEY"], values["GEMINI_MODEL"]
    if provider == "gemini_openai_compat":
        return values["GEMINI_OPENAI_BASE_URL"], values["GEMINI_API_KEY"], values["GEMINI_MODEL"]
    return values["BAILIAN_BASE_URL"], values["DASHSCOPE_API_KEY"], "qwen3.5-plus-2026-02-15"


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--provider",
        choices=("openai", "grok", "anthropic", "gemini", "gemini_openai_compat", "bailian"),
        required=True,
    )
    parser.add_argument("--questions", type=Path, required=True)
    parser.add_argument("--source-root", type=Path, required=True)
    parser.add_argument(
        "--task-contract", type=Path,
        help="Optional frozen task contract prepended identically to every selected item.",
    )
    parser.add_argument(
        "--confidential-config", type=Path,
        help="Optional KEY=VALUE file. Process environment variables take precedence.",
    )
    parser.add_argument("--output", type=Path, required=True)
    parser.add_argument("--model")
    parser.add_argument("--max-requests", type=int)
    parser.add_argument("--track", choices=("S", "I"))
    parser.add_argument("--question-type", choices=("choice", "open"))
    parser.add_argument("--task")
    parser.add_argument("--subtrack")
    parser.add_argument("--timeout", type=float, default=120.0)
    parser.add_argument("--retries", type=int, default=4)
    parser.add_argument("--max-tokens", type=int, default=900)
    parser.add_argument("--reasoning-effort", default="high")
    parser.add_argument(
        "--wire-api", choices=("responses", "chat_completions"), default="responses",
        help="OpenAI-compatible transport. chat_completions is recorded and only valid for --provider openai.",
    )
    parser.add_argument("--format-reasks", type=int, default=1)
    parser.add_argument(
        "--format-mode", choices=("auto", "json_schema", "json_object", "prompt_only"),
        default="auto", help="Use auto fallback or a recorded single response-format mode.",
    )
    args = parser.parse_args()
    if args.provider != "openai" and args.wire_api != "responses":
        parser.error("--wire-api chat_completions is only valid with --provider openai")

    values = load_confidential_config(args.confidential_config) if args.confidential_config else {}
    values.update(os.environ)
    base_url, key, default_model = provider_config(args.provider, values)
    model = args.model or default_model
    rows = load_jsonl(args.questions)
    if args.track:
        rows = [row for row in rows if row["track"] == args.track]
    if args.question_type:
        rows = [row for row in rows if row["question_type"] == args.question_type]
    if args.task:
        rows = [row for row in rows if row["task"] == args.task]
    if args.subtrack:
        rows = [row for row in rows if row["subtrack"] == args.subtrack]
    existing = load_jsonl(args.output) if args.output.exists() else []
    completed = completed_qa_ids(existing, args.provider, model)
    pending = [row for row in rows if row["qa_id"] not in completed]
    if args.max_requests is not None:
        pending = pending[:args.max_requests]
    args.output.parent.mkdir(parents=True, exist_ok=True)
    manifest_path = args.output.with_suffix(args.output.suffix + ".manifest.json")
    task_contract = args.task_contract.read_text(encoding="utf-8").strip() if args.task_contract else None
    manifest_metadata = {
        "schema_version": "FWB-FG9-API-RUN-MANIFEST-v1",
        "runner_version": RUNNER_VERSION,
        "prompt_version": PROMPT_VERSION,
        "response_schema_version": SCHEMA_VERSION,
        "provider": args.provider,
        "requested_model": model,
        "questions": str(args.questions.resolve()),
        "questions_sha256": file_digest(args.questions),
        "source_root": str(args.source_root.resolve()),
        "task_contract": str(args.task_contract.resolve()) if args.task_contract else None,
        "task_contract_sha256": file_digest(args.task_contract) if args.task_contract else None,
        "filters": {key: value for key, value in {
            "track": args.track, "question_type": args.question_type,
            "task": args.task, "subtrack": args.subtrack,
        }.items() if value is not None},
        "selected_question_count": len(rows),
        "pending_question_count_at_start": len(pending),
        "selected_qa_ids_sha256": hashlib.sha256(
            "\n".join(row["qa_id"] for row in rows).encode()
        ).hexdigest(),
        "reasoning_effort": args.reasoning_effort,
        "max_output_tokens": args.max_tokens,
        "transport_retry_limit": args.retries,
        "format_reask_limit": args.format_reasks,
        "requested_format_mode": args.format_mode,
        "wire_api": args.wire_api,
    }
    all_records = list(existing)
    write_run_manifest(manifest_path, manifest_metadata, all_records)
    system = ("You are evaluating a fire-physics benchmark. Use only the supplied observation. "
              "Return one JSON object matching the requested schema, without markdown or commentary.")
    session = requests.Session()
    with args.output.open("a", encoding="utf-8") as stream:
        for position, row in enumerate(pending, 1):
            record = {"qa_id": row["qa_id"], "provider": args.provider,
                      "requested_model": model, "model": model,
                      "runner_version": RUNNER_VERSION, "prompt_version": PROMPT_VERSION,
                      "response_schema_version": SCHEMA_VERSION,
                      "question_type": row["question_type"], "task": row["task"], "status": "error",
                      "started_at_utc": datetime.now(timezone.utc).isoformat(),
                      "attempts": [], "format_reasks": 0}
            final_raw_response = None
            try:
                images = encode_images(row, args.source_root)
                prompt = prompt_text(row, task_contract)
                schema = response_schema(row)
                prompt += "\nRequired JSON Schema:\n" + json.dumps(schema, separators=(",", ":"))
                record["request_fingerprint"] = {
                    "prompt_sha256": hashlib.sha256(prompt.encode()).hexdigest(),
                    "schema_sha256": hashlib.sha256(json.dumps(schema, sort_keys=True).encode()).hexdigest(),
                    "image_count": len(images),
                }
                parsed = None
                schema_valid = False
                raw_text = ""
                received_response = False
                modes = (("json_schema", "json_object", "prompt_only")
                         if args.format_mode == "auto" else (args.format_mode,))
                for mode in modes:
                    path, headers, payload = build_request(args.provider, model, system, prompt, images, schema, mode,
                                                           args.max_tokens, args.reasoning_effort, args.wire_api)
                    url = base_url.rstrip("/") + path
                    headers = {name: value.replace("{key}", key) for name, value in headers.items()}
                    try:
                        response, transport_retries, latency = post_with_retry(
                            session, url, headers, payload, args.timeout, args.retries)
                    except RuntimeError as exc:
                        record["attempts"].append({
                            "mode": mode, "status": "request_error",
                            "error": str(exc)[:1000],
                            "error_classification": classify_exception(exc),
                        })
                        if "HTTP 400" in str(exc) or "HTTP 404" in str(exc) or "HTTP 422" in str(exc):
                            continue
                        raise
                    raw_text = extract_text(args.provider, response)
                    final_raw_response = response
                    received_response = True
                    parsed = parse_json(raw_text)
                    schema_issues = validation_errors(parsed, schema)
                    schema_valid = not schema_issues
                    record["attempts"].append({"mode": mode, "status": "response", "latency_s": latency,
                                               "transport_retries": transport_retries,
                                               "usage": usage_record(args.provider, response),
                                               "usage_normalized": normalized_usage(args.provider, response),
                                               "provider_cost": provider_cost(response),
                                               "response_model": response_model(args.provider, response),
                                               "raw_response": response,
                                               "parsed_json": parsed is not None, "schema_valid": schema_valid,
                                               "schema_errors": schema_issues[:12]})
                    record["format_mode"] = mode
                    record["usage"] = usage_record(args.provider, response)
                    record["usage_normalized"] = normalized_usage(args.provider, response)
                    record["provider_cost"] = provider_cost(response)
                    record["response_model"] = response_model(args.provider, response)
                    if schema_valid:
                        break
                if not received_response:
                    raise RuntimeError("all response-format modes were rejected before model inference")
                for _ in range(args.format_reasks):
                    if schema_valid:
                        break
                    record["format_reasks"] += 1
                    reask = prompt + "\nYour previous output was not valid JSON. Return only one valid JSON object now."
                    path, headers, payload = build_request(args.provider, model, system, reask, images, schema,
                                                           "json_object", args.max_tokens, args.reasoning_effort,
                                                           args.wire_api)
                    headers = {name: value.replace("{key}", key) for name, value in headers.items()}
                    response, transport_retries, latency = post_with_retry(
                        session, base_url.rstrip("/") + path, headers, payload, args.timeout, args.retries)
                    final_raw_response = response
                    raw_text = extract_text(args.provider, response)
                    parsed = parse_json(raw_text)
                    schema_issues = validation_errors(parsed, schema)
                    schema_valid = not schema_issues
                    record["attempts"].append({"mode": "format_reask", "status": "response", "latency_s": latency,
                                               "transport_retries": transport_retries,
                                               "usage": usage_record(args.provider, response),
                                               "usage_normalized": normalized_usage(args.provider, response),
                                               "provider_cost": provider_cost(response),
                                               "response_model": response_model(args.provider, response),
                                               "raw_response": response,
                                               "parsed_json": parsed is not None, "schema_valid": schema_valid,
                                               "schema_errors": schema_issues[:12]})
                    record["format_mode"] = "format_reask"
                    record["usage"] = usage_record(args.provider, response)
                    record["usage_normalized"] = normalized_usage(args.provider, response)
                    record["provider_cost"] = provider_cost(response)
                    record["response_model"] = response_model(args.provider, response)
                record["response"] = parsed if parsed is not None else raw_text
                record["raw_text"] = raw_text
                record["raw_response"] = final_raw_response
                record["status"] = "ok" if schema_valid else ("schema_error" if parsed is not None else "format_error")
                if not schema_valid:
                    record["error_classification"] = "format" if parsed is not None else "parse"
                reported_model = record.get("response_model")
                if (args.provider == "openai" and reported_model is not None
                        and not model_identity_matches(model, reported_model)):
                    record["status"] = "model_mismatch"
                    record["error_classification"] = "model_identity"
            except Exception as exc:  # Each item is checkpointed; one provider failure does not discard the gate.
                record["error_type"] = type(exc).__name__
                record["error"] = str(exc)[:1200]
                attempt_classes = {
                    attempt["error_classification"]
                    for attempt in record["attempts"]
                    if attempt.get("error_classification")
                }
                record["error_classification"] = (
                    next(iter(attempt_classes)) if len(attempt_classes) == 1
                    else classify_exception(exc)
                )
            record["attempt_count"] = len(record["attempts"])
            record["transport_retries"] = sum(
                attempt.get("transport_retries", 0) for attempt in record["attempts"]
            )
            record["finished_at_utc"] = datetime.now(timezone.utc).isoformat()
            stream.write(json.dumps(record, separators=(",", ":")) + "\n")
            stream.flush()
            all_records.append(record)
            write_run_manifest(manifest_path, manifest_metadata, all_records)
            print(json.dumps({"finished": position, "selected": len(pending), "qa_id": row["qa_id"],
                              "status": record["status"], "provider": args.provider, "model": model}))


if __name__ == "__main__":
    main()