src/shiftedx_bench/runner.py

from __future__ import annotations

import os
import uuid
from pathlib import Path
from typing import Any, Iterable

from .api import OpenAIClient
from .models import BenchCase, CaseResult
from .scoring import score_response
from .util import append_jsonl, read_jsonl, sha256_json


def build_payload(case: BenchCase, model: str, variant: dict[str, Any]) -> dict[str, Any]:
    payload: dict[str, Any] = {
        "model": model,
        "messages": case.messages,
        "temperature": 0,
        "top_p": 1,
        "max_tokens": case.max_output_tokens,
        "seed": 7319,
    }
    if case.tools:
        payload["tools"] = case.tools
        payload["tool_choice"] = "auto"
    payload.update(case.request_overrides)
    payload.update(variant.get("request_overrides") or {})
    return payload


def run_cases(
    cases: Iterable[BenchCase],
    *,
    client: OpenAIClient,
    model: str,
    output_path: Path,
    variants: list[dict[str, Any]] | None = None,
    run_id: str | None = None,
    stream: bool = False,
) -> list[dict[str, Any]]:
    run_id = run_id or str(uuid.uuid4())
    variants = variants or [{"label": "default", "request_overrides": {}}]
    completed = {
        (row.get("case_id"), row.get("variant"))
        for row in read_jsonl(output_path)
        if row.get("schema_version") == "1.0"
    }
    new_rows: list[dict[str, Any]] = []
    for case in cases:
        for variant in variants:
            label = str(variant["label"])
            if (case.case_id, label) in completed:
                continue
            payload = build_payload(case, model, variant)
            request_hash = sha256_json(payload)
            error = None
            try:
                response = client.complete(payload, stream=stream and not case.tools)
                scored = score_response(case.scorer, case.expected, response)
                passed = scored.passed
                error = scored.error
                if "target_prompt_tokens" in case.metadata:
                    server_tokens = response.get("prompt_tokens")
                    requested_tokens = case.metadata["target_prompt_tokens"]
                    if server_tokens != requested_tokens:
                        passed = False
                        error = (
                            f"server prompt token mismatch: requested={requested_tokens}, "
                            f"reported={server_tokens}"
                        )
                telemetry = {
                    key: response.get(key)
                    for key in (
                        "wall_s",
                        "ttft_s",
                        "prompt_tokens",
                        "completion_tokens",
                        "end_to_end_tokens_per_second",
                        "prefill_tokens_per_second",
                        "decode_tokens_per_second",
                        "active_memory_bytes",
                        "cache_memory_bytes",
                        "mtplx_stats",
                    )
                }
                usage = response.get("usage") or {}
                telemetry["cached_prompt_tokens"] = (
                    (usage.get("prompt_tokens_details") or {}).get("cached_tokens")
                )
                stats = response.get("mtplx_stats") or {}
                accepted = stats.get("accepted_drafts")
                drafted = stats.get("drafted_tokens")
                telemetry["accepted_draft_ratio"] = (
                    accepted / drafted
                    if isinstance(accepted, (int, float)) and isinstance(drafted, (int, float)) and drafted
                    else stats.get("accepted_draft_ratio")
                )
                result = CaseResult(
                    schema_version="1.0",
                    run_id=run_id,
                    suite_id=case.suite_id,
                    case_id=case.case_id,
                    lane=case.lane,
                    variant=label,
                    passed=passed,
                    score=scored.value if passed else 0.0,
                    score_max=scored.maximum,
                    error=error,
                    response={
                        key: response.get(key)
                        for key in (
                            "model",
                            "content",
                            "reasoning_content",
                            "tool_calls",
                            "finish_reason",
                            "usage",
                        )
                    },
                    telemetry=telemetry,
                    metadata=case.metadata,
                    request_hash=request_hash,
                )
            except Exception as exc:
                result = CaseResult(
                    schema_version="1.0",
                    run_id=run_id,
                    suite_id=case.suite_id,
                    case_id=case.case_id,
                    lane=case.lane,
                    variant=label,
                    passed=False,
                    score=0.0,
                    score_max=1.0,
                    error=f"{type(exc).__name__}: {exc}",
                    response={},
                    telemetry={},
                    metadata=case.metadata,
                    request_hash=request_hash,
                )
            row = result.to_dict()
            append_jsonl(output_path, [row])
            new_rows.append(row)
    return new_rows


def api_key_from_env(name: str | None) -> str | None:
    if not name:
        return None
    value = os.environ.get(name)
    if not value:
        raise RuntimeError(f"API-key environment variable is not set: {name}")
    return value