| """Small model adapter interface for PhyCAD-Bench.""" |
|
|
| import json |
| import os |
| import socket |
| import urllib.error |
| import urllib.request |
| from dataclasses import dataclass |
| from typing import Protocol |
| from urllib.parse import urlsplit |
|
|
|
|
| class ModelRequestError(ValueError): |
| """The model endpoint rejected a request or returned an invalid response.""" |
|
|
|
|
| class ModelTimeoutError(TimeoutError): |
| """The model did not answer within the configured time.""" |
|
|
|
|
| @dataclass |
| class ModelResponse: |
| text: str |
| served_model: str | None = None |
| response_id: str | None = None |
| finish_reason: str | None = None |
| usage: dict | None = None |
|
|
|
|
| class ModelAdapter(Protocol): |
| def generate(self, model: str, messages: list[dict], settings: dict, timeout: int) -> ModelResponse: |
| """Return one model answer for the given messages.""" |
|
|
|
|
| class OpenAICompatibleAdapter: |
| def __init__(self, base_url: str, api_key_env: str | None = None): |
| parsed = urlsplit(base_url) |
| if parsed.scheme not in ("http", "https") or not parsed.netloc or parsed.query or parsed.fragment: |
| raise ValueError("--base-url must be an HTTP(S) API base URL") |
| self.base_url = base_url.rstrip("/") |
| self.api_key_env = api_key_env |
| self.api_key = None |
| if api_key_env: |
| self.api_key = os.environ.get(api_key_env) |
| if not self.api_key: |
| raise ValueError(f"Set {api_key_env} before running the model") |
|
|
| def generate(self, model: str, messages: list[dict], settings: dict, timeout: int) -> ModelResponse: |
| headers = {"Content-Type": "application/json"} |
| if self.api_key: |
| headers["Authorization"] = f"Bearer {self.api_key}" |
| request = urllib.request.Request( |
| self.base_url + "/chat/completions", |
| data=json.dumps({"model": model, "messages": messages, **settings}).encode(), |
| headers=headers, |
| method="POST", |
| ) |
| try: |
| with urllib.request.urlopen(request, timeout=timeout) as response: |
| completion = json.load(response) |
| except urllib.error.HTTPError as exc: |
| raise ModelRequestError(f"Model endpoint returned HTTP {exc.code}") from None |
| except (socket.timeout, TimeoutError): |
| raise ModelTimeoutError(f"Model request exceeded {timeout} seconds") from None |
| except urllib.error.URLError as exc: |
| if isinstance(exc.reason, TimeoutError): |
| raise ModelTimeoutError(f"Model request exceeded {timeout} seconds") from None |
| raise ModelRequestError(f"Could not reach model endpoint: {exc.reason}") from None |
| except json.JSONDecodeError: |
| raise ModelRequestError("Model endpoint did not return JSON") from None |
|
|
| try: |
| choice = completion["choices"][0] |
| content = choice["message"].get("content") or "" |
| if isinstance(content, list): |
| content = "".join(part.get("text", "") for part in content if isinstance(part, dict)) |
| if not isinstance(content, str): |
| raise TypeError("Response content is not text") |
| return ModelResponse( |
| text=content, |
| served_model=completion.get("model"), |
| response_id=completion.get("id"), |
| finish_reason=choice.get("finish_reason"), |
| usage=completion.get("usage"), |
| ) |
| except (KeyError, IndexError, TypeError, AttributeError) as exc: |
| raise ModelRequestError(f"Model endpoint returned an invalid chat completion: {exc}") from None |
|
|
