| from __future__ import annotations |
|
|
| import json |
| import time |
| import urllib.error |
| import urllib.request |
| from dataclasses import dataclass |
| from typing import Any |
|
|
|
|
| @dataclass |
| class OpenAIClient: |
| base_url: str |
| api_key: str | None = None |
| timeout_s: float = 600.0 |
|
|
| def _request(self, payload: dict[str, Any]): |
| headers = {"Content-Type": "application/json"} |
| if self.api_key: |
| headers["Authorization"] = f"Bearer {self.api_key}" |
| return urllib.request.Request( |
| self.base_url.rstrip("/") + "/chat/completions", |
| data=json.dumps(payload).encode("utf-8"), |
| headers=headers, |
| ) |
|
|
| def complete(self, payload: dict[str, Any], *, stream: bool = False) -> dict[str, Any]: |
| body = dict(payload) |
| body["stream"] = bool(stream) |
| request = self._request(body) |
| started = time.perf_counter() |
| try: |
| with urllib.request.urlopen(request, timeout=self.timeout_s) as response: |
| if stream: |
| value = self._read_stream(response, started) |
| else: |
| value = json.loads(response.read().decode("utf-8")) |
| except urllib.error.HTTPError as exc: |
| detail = exc.read().decode("utf-8", errors="replace")[-4000:] |
| raise RuntimeError(f"HTTP {exc.code}: {detail}") from exc |
| wall_s = time.perf_counter() - started |
| return self._normalize(value, wall_s=wall_s, ttft_s=value.pop("_ttft_s", None)) |
|
|
| @staticmethod |
| def _read_stream(response: Any, started: float) -> dict[str, Any]: |
| content: list[str] = [] |
| reasoning: list[str] = [] |
| usage: dict[str, Any] = {} |
| stats: dict[str, Any] = {} |
| finish_reason = None |
| first_token_at = None |
| model = None |
| for raw_line in response: |
| line = raw_line.decode("utf-8", errors="replace").strip() |
| if not line.startswith("data:"): |
| continue |
| data = line[5:].strip() |
| if data == "[DONE]": |
| break |
| chunk = json.loads(data) |
| model = chunk.get("model") or model |
| usage = chunk.get("usage") or usage |
| stats = chunk.get("mtplx_stats") or stats |
| choice = (chunk.get("choices") or [{}])[0] |
| delta = choice.get("delta") or {} |
| text = delta.get("content") or "" |
| thought = delta.get("reasoning_content") or "" |
| if first_token_at is None and (text or thought): |
| first_token_at = time.perf_counter() |
| content.append(text) |
| reasoning.append(thought) |
| finish_reason = choice.get("finish_reason") or finish_reason |
| return { |
| "model": model, |
| "choices": [ |
| { |
| "finish_reason": finish_reason, |
| "message": { |
| "role": "assistant", |
| "content": "".join(content), |
| "reasoning_content": "".join(reasoning), |
| }, |
| } |
| ], |
| "usage": usage, |
| "mtplx_stats": stats, |
| "_ttft_s": None if first_token_at is None else first_token_at - started, |
| } |
|
|
| @staticmethod |
| def _normalize(value: dict[str, Any], *, wall_s: float, ttft_s: float | None) -> dict[str, Any]: |
| choice = (value.get("choices") or [{}])[0] |
| message = choice.get("message") or {} |
| usage = value.get("usage") or {} |
| stats = value.get("mtplx_stats") or usage.get("mtplx_stats") or {} |
| if ttft_s is None and isinstance(stats.get("ttft_s"), (int, float)): |
| ttft_s = float(stats["ttft_s"]) |
| completion_tokens = usage.get("completion_tokens") |
| prompt_tokens = usage.get("prompt_tokens") |
| return { |
| "model": value.get("model"), |
| "content": message.get("content") or "", |
| "reasoning_content": message.get("reasoning_content") or "", |
| "tool_calls": message.get("tool_calls") or [], |
| "finish_reason": choice.get("finish_reason"), |
| "usage": usage, |
| "mtplx_stats": stats, |
| "wall_s": wall_s, |
| "ttft_s": ttft_s, |
| "prompt_tokens": prompt_tokens, |
| "completion_tokens": completion_tokens, |
| "end_to_end_tokens_per_second": ( |
| completion_tokens / wall_s |
| if isinstance(completion_tokens, int) and wall_s > 0 |
| else None |
| ), |
| "prefill_tokens_per_second": ( |
| stats.get("prefill_tok_s") |
| or ( |
| stats.get("new_prefill_tokens") / stats.get("prefill_elapsed_s") |
| if isinstance(stats.get("new_prefill_tokens"), (int, float)) |
| and isinstance(stats.get("prefill_elapsed_s"), (int, float)) |
| and stats.get("prefill_elapsed_s") |
| else None |
| ) |
| ), |
| "decode_tokens_per_second": stats.get("decode_tok_s") or stats.get("tok_s"), |
| "active_memory_bytes": stats.get("active_memory_bytes"), |
| "cache_memory_bytes": stats.get("cache_memory_bytes"), |
| } |
|
|
