File size: 3,628 Bytes
99510bd
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
"""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