urouter-sdk 0.1.0__tar.gz

urouter_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.5
+Name: urouter-sdk
+Version: 0.1.0
+Summary: OpenAI-compatible Python client for uRouter (free + paid)
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: httpx[http2]>=0.27.0
+Requires-Dist: orjson>=3.10.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# urouter
+
+OpenAI-compatible Python client for [uRouter](https://urouter.net) / [chat.urouter.net](https://chat.urouter.net).
+
+Free presets (no API key): **normal** (censored) and **uncensored**.  
+Paid path uses `https://api.urouter.net/v1` with a Bearer key.
+
+## Install
+
+```bash
+pip install urouter
+```
+
+## Free chat
+
+```python
+from urouter import URouter
+
+client = URouter()
+
+# censored free
+r = client.chat.completions.create(
+    model="normal",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+print(r.choices[0].message.content)
+
+# uncensored free
+r = client.chat.completions.create(
+    model="uncensored",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+print(r.content)
+```
+
+Aliases: `normal` / `censored` / `free` → `deepseek-v4.1-flash`  
+`uncensored` → `gemma-4-uncensored`
+
+## Streaming
+
+```python
+stream = client.chat.completions.create(
+    model="normal",
+    messages=[{"role": "user", "content": "Hi"}],
+    stream=True,
+)
+
+for chunk in stream:
+    delta = chunk.choices[0].delta.content
+    if delta:
+        print(delta, end="", flush=True)
+```
+
+## Paid (OpenAI-compatible)
+
+```python
+from urouter import OpenAI
+
+client = OpenAI(api_key="ur-...")
+
+r = client.chat.completions.create(
+    model="deepseek-v4-flash",
+    messages=[{"role": "user", "content": "Hi"}],
+)
+```
+
+## Models
+
+```python
+for m in client.models.list().data:
+    print(m.id)
+```
+
+## Drop-in shape
+
+```python
+client.chat.completions.create(...)
+client.models.list()
+client.models.retrieve(id)
+```

urouter_sdk-0.1.0/README.md

@@ -0,0 +1,80 @@
+# urouter
+
+OpenAI-compatible Python client for [uRouter](https://urouter.net) / [chat.urouter.net](https://chat.urouter.net).
+
+Free presets (no API key): **normal** (censored) and **uncensored**.  
+Paid path uses `https://api.urouter.net/v1` with a Bearer key.
+
+## Install
+
+```bash
+pip install urouter
+```
+
+## Free chat
+
+```python
+from urouter import URouter
+
+client = URouter()
+
+# censored free
+r = client.chat.completions.create(
+    model="normal",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+print(r.choices[0].message.content)
+
+# uncensored free
+r = client.chat.completions.create(
+    model="uncensored",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+print(r.content)
+```
+
+Aliases: `normal` / `censored` / `free` → `deepseek-v4.1-flash`  
+`uncensored` → `gemma-4-uncensored`
+
+## Streaming
+
+```python
+stream = client.chat.completions.create(
+    model="normal",
+    messages=[{"role": "user", "content": "Hi"}],
+    stream=True,
+)
+
+for chunk in stream:
+    delta = chunk.choices[0].delta.content
+    if delta:
+        print(delta, end="", flush=True)
+```
+
+## Paid (OpenAI-compatible)
+
+```python
+from urouter import OpenAI
+
+client = OpenAI(api_key="ur-...")
+
+r = client.chat.completions.create(
+    model="deepseek-v4-flash",
+    messages=[{"role": "user", "content": "Hi"}],
+)
+```
+
+## Models
+
+```python
+for m in client.models.list().data:
+    print(m.id)
+```
+
+## Drop-in shape
+
+```python
+client.chat.completions.create(...)
+client.models.list()
+client.models.retrieve(id)
+```

urouter_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "urouter-sdk"
+version = "0.1.0"
+description = "OpenAI-compatible Python client for uRouter (free + paid)"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx[http2]>=0.27.0",
+    "orjson>=3.10.0",
+]
+readme = "README.md"
+license = { text = "MIT" }
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-asyncio"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["urouter"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "urouter/**",
+    "README.md",
+    "pyproject.toml",
+]
+exclude = [
+    ".github/**",
+    "examples/**",
+    "**/__pycache__/**",
+    "**/*.pyc",
+]

urouter_sdk-0.1.0/urouter/__init__.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from urouter._client import Client, OpenAI, URouter
+from urouter._exceptions import (
+    APIConnectionError,
+    APIError,
+    APITimeoutError,
+    AuthenticationError,
+    BadRequestError,
+    NotFoundError,
+    RateLimitError,
+    URouterError,
+)
+from urouter._types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ChatCompletionMessage,
+    Choice,
+    ChoiceDelta,
+    ChunkChoice,
+    CompletionUsage,
+    Model,
+    ModelList,
+    Stream,
+)
+
+__all__ = (
+    "URouter",
+    "OpenAI",
+    "Client",
+    "URouterError",
+    "APIError",
+    "AuthenticationError",
+    "RateLimitError",
+    "BadRequestError",
+    "NotFoundError",
+    "APIConnectionError",
+    "APITimeoutError",
+    "ChatCompletion",
+    "ChatCompletionChunk",
+    "ChatCompletionMessage",
+    "Choice",
+    "ChoiceDelta",
+    "ChunkChoice",
+    "CompletionUsage",
+    "Model",
+    "ModelList",
+    "Stream",
+)
+
+__version__ = "0.1.0"

urouter_sdk-0.1.0/urouter/_client.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any
+
+from urouter._constants import API_BASE, CHAT_BASE, DEFAULT_HEADERS, DEFAULT_TIMEOUT
+from urouter._http import HTTP
+from urouter.resources.chat import Chat
+from urouter.resources.models import Models
+
+
+class URouter:
+    __slots__ = (
+        "api_key",
+        "base_url",
+        "timeout",
+        "_http",
+        "chat",
+        "models",
+    )
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str | None = None,
+        timeout: float = DEFAULT_TIMEOUT,
+        proxy: str | None = None,
+        http2: bool = True,
+        default_headers: dict[str, str] | None = None,
+    ) -> None:
+        self.api_key = api_key
+
+        self.base_url = base_url or (API_BASE if api_key else CHAT_BASE)
+
+        self.timeout = timeout
+
+        headers = dict(DEFAULT_HEADERS)
+
+        if default_headers:
+            headers.update(default_headers)
+
+        self._http = HTTP(
+            timeout=timeout,
+            headers=headers,
+            proxy=proxy,
+            http2=http2,
+        )
+
+        self.chat = Chat(self)
+
+        self.models = Models(self)
+
+    def _auth_headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {}
+
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        return headers
+
+    def _chat_headers(self) -> dict[str, str]:
+        return {
+            "Origin": CHAT_BASE,
+            "Referer": f"{CHAT_BASE}/",
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> URouter:
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.close()
+
+
+class OpenAI(URouter):
+    pass
+
+
+Client = URouter

urouter_sdk-0.1.0/urouter/_constants.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+CHAT_BASE: str = "https://chat.urouter.net"
+
+API_BASE: str = "https://api.urouter.net/v1"
+
+DEFAULT_TIMEOUT: float = 120.0
+
+FREE_PRESETS: dict[str, tuple[str, str]] = {
+    "normal": ("deepseek-v4.1-flash", "normal"),
+    "censored": ("deepseek-v4.1-flash", "normal"),
+    "free": ("deepseek-v4.1-flash", "normal"),
+    "uncensored": ("gemma-4-uncensored", "uncensored"),
+    "deepseek-v4.1-flash": ("deepseek-v4.1-flash", "normal"),
+    "gemma-4-uncensored": ("gemma-4-uncensored", "uncensored"),
+}
+
+DEFAULT_HEADERS: dict[str, str] = {
+    "Accept": "application/json",
+    "Content-Type": "application/json",
+}

urouter_sdk-0.1.0/urouter/_exceptions.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class URouterError(Exception):
+    def __init__(self, message: str, *, status_code: int | None = None, body: Any = None) -> None:
+        super().__init__(message)
+
+        self.message = message
+
+        self.status_code = status_code
+
+        self.body = body
+
+
+class APIError(URouterError):
+    pass
+
+
+class AuthenticationError(APIError):
+    pass
+
+
+class RateLimitError(APIError):
+    pass
+
+
+class BadRequestError(APIError):
+    pass
+
+
+class NotFoundError(APIError):
+    pass
+
+
+class APIConnectionError(URouterError):
+    pass
+
+
+class APITimeoutError(URouterError):
+    pass

urouter_sdk-0.1.0/urouter/_http.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+from typing import Any, Iterator
+
+import httpx
+import orjson
+
+from urouter._exceptions import (
+    APIConnectionError,
+    APIError,
+    APITimeoutError,
+    AuthenticationError,
+    BadRequestError,
+    NotFoundError,
+    RateLimitError,
+)
+
+
+class HTTP:
+    __slots__ = ("_client",)
+
+    def __init__(
+        self,
+        *,
+        timeout: float,
+        headers: dict[str, str],
+        proxy: str | None = None,
+        http2: bool = True,
+    ) -> None:
+        kwargs: dict[str, Any] = {
+            "timeout": httpx.Timeout(timeout, connect=10.0),
+            "headers": headers,
+            "http2": http2,
+            "follow_redirects": True,
+        }
+
+        if proxy:
+            kwargs["proxy"] = proxy
+
+        self._client = httpx.Client(**kwargs)
+
+    def close(self) -> None:
+        self._client.close()
+
+    def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        json_body: Any = None,
+        params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> httpx.Response:
+        content = None
+
+        req_headers = dict(headers or {})
+
+        if json_body is not None:
+            content = orjson.dumps(json_body)
+
+            req_headers.setdefault("Content-Type", "application/json")
+
+        try:
+            resp = self._client.request(
+                method,
+                url,
+                content=content,
+                params=params,
+                headers=req_headers,
+            )
+        except httpx.TimeoutException as e:
+            raise APITimeoutError(str(e)) from e
+        except httpx.HTTPError as e:
+            raise APIConnectionError(str(e)) from e
+
+        return resp
+
+    def stream(
+        self,
+        method: str,
+        url: str,
+        *,
+        json_body: Any = None,
+        headers: dict[str, str] | None = None,
+    ) -> Iterator[bytes]:
+        content = None
+
+        req_headers = dict(headers or {})
+
+        if json_body is not None:
+            content = orjson.dumps(json_body)
+
+            req_headers.setdefault("Content-Type", "application/json")
+
+        try:
+            with self._client.stream(
+                method,
+                url,
+                content=content,
+                headers=req_headers,
+            ) as resp:
+                if resp.status_code >= 400:
+                    raw = resp.read()
+
+                    self.raise_for_status(resp.status_code, raw)
+
+                yield from resp.iter_bytes()
+        except httpx.TimeoutException as e:
+            raise APITimeoutError(str(e)) from e
+        except httpx.HTTPError as e:
+            raise APIConnectionError(str(e)) from e
+
+    @staticmethod
+    def parse_json(resp: httpx.Response) -> Any:
+        if not resp.content:
+            return None
+
+        return orjson.loads(resp.content)
+
+    @staticmethod
+    def raise_for_status(status: int, body: bytes | Any) -> None:
+        data: Any
+
+        if isinstance(body, (bytes, bytearray)):
+            try:
+                data = orjson.loads(body) if body else None
+            except Exception:
+                data = body.decode("utf-8", errors="replace") if body else None
+        else:
+            data = body
+
+        message = None
+
+        if isinstance(data, dict):
+            err = data.get("error")
+
+            if isinstance(err, dict):
+                message = err.get("message") or err.get("code")
+            elif isinstance(err, str):
+                message = err
+            else:
+                message = data.get("message")
+
+        if not message:
+            message = f"HTTP {status}"
+
+        if status == 401:
+            raise AuthenticationError(str(message), status_code=status, body=data)
+
+        if status == 404:
+            raise NotFoundError(str(message), status_code=status, body=data)
+
+        if status == 429:
+            raise RateLimitError(str(message), status_code=status, body=data)
+
+        if 400 <= status < 500:
+            raise BadRequestError(str(message), status_code=status, body=data)
+
+        raise APIError(str(message), status_code=status, body=data)

urouter_sdk-0.1.0/urouter/_types.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Iterator, Literal
+
+
+Role = Literal["system", "user", "assistant", "tool", "function", "developer"]
+
+
+@dataclass(slots=True)
+class ChatCompletionMessage:
+    role: str
+
+    content: str | None = None
+
+    reasoning: str | None = None
+
+
+@dataclass(slots=True)
+class Choice:
+    index: int
+
+    message: ChatCompletionMessage
+
+    finish_reason: str | None = "stop"
+
+    logprobs: Any = None
+
+
+@dataclass(slots=True)
+class CompletionUsage:
+    prompt_tokens: int = 0
+
+    completion_tokens: int = 0
+
+    total_tokens: int = 0
+
+
+@dataclass(slots=True)
+class ChatCompletion:
+    id: str
+
+    choices: list[Choice]
+
+    created: int
+
+    model: str
+
+    object: str = "chat.completion"
+
+    usage: CompletionUsage | None = None
+
+    system_fingerprint: str | None = None
+
+    @property
+    def content(self) -> str:
+        if not self.choices:
+            return ""
+
+        return self.choices[0].message.content or ""
+
+
+@dataclass(slots=True)
+class ChoiceDelta:
+    role: str | None = None
+
+    content: str | None = None
+
+    reasoning: str | None = None
+
+
+@dataclass(slots=True)
+class ChunkChoice:
+    index: int
+
+    delta: ChoiceDelta
+
+    finish_reason: str | None = None
+
+
+@dataclass(slots=True)
+class ChatCompletionChunk:
+    id: str
+
+    choices: list[ChunkChoice]
+
+    created: int
+
+    model: str
+
+    object: str = "chat.completion.chunk"
+
+
+@dataclass(slots=True)
+class Model:
+    id: str
+
+    object: str = "model"
+
+    created: int = 0
+
+    owned_by: str = "urouter"
+
+    name: str | None = None
+
+    brand: str | None = None
+
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class ModelList:
+    data: list[Model]
+
+    object: str = "list"
+
+
+class Stream[T]:
+    __slots__ = ("_iterator",)
+
+    def __init__(self, iterator: Iterator[T]) -> None:
+        self._iterator = iterator
+
+    def __iter__(self) -> Iterator[T]:
+        return self._iterator
+
+    def __next__(self) -> T:
+        return next(self._iterator)

urouter_sdk-0.1.0/urouter/resources/__init__.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from urouter.resources.chat import Chat, Completions
+from urouter.resources.models import Models
+
+__all__ = ("Chat", "Completions", "Models")

urouter_sdk-0.1.0/urouter/resources/chat.py

@@ -0,0 +1,494 @@
+from __future__ import annotations
+
+import time
+import uuid
+from typing import TYPE_CHECKING, Any, Iterator, Literal, overload
+
+import orjson
+
+from urouter._constants import CHAT_BASE, FREE_PRESETS
+from urouter._types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ChatCompletionMessage,
+    Choice,
+    ChoiceDelta,
+    ChunkChoice,
+    CompletionUsage,
+    Stream,
+)
+
+if TYPE_CHECKING:
+    from urouter._client import URouter
+
+
+class Completions:
+    __slots__ = ("_client",)
+
+    def __init__(self, client: URouter) -> None:
+        self._client = client
+
+    @overload
+    def create(
+        self,
+        *,
+        messages: list[dict[str, Any]],
+        model: str = ...,
+        stream: Literal[False] = False,
+        max_tokens: int | None = ...,
+        temperature: float | None = ...,
+        top_p: float | None = ...,
+        stop: str | list[str] | None = ...,
+        presence_penalty: float | None = ...,
+        frequency_penalty: float | None = ...,
+        user: str | None = ...,
+        extra_body: dict[str, Any] | None = ...,
+    ) -> ChatCompletion: ...
+
+    @overload
+    def create(
+        self,
+        *,
+        messages: list[dict[str, Any]],
+        model: str = ...,
+        stream: Literal[True],
+        max_tokens: int | None = ...,
+        temperature: float | None = ...,
+        top_p: float | None = ...,
+        stop: str | list[str] | None = ...,
+        presence_penalty: float | None = ...,
+        frequency_penalty: float | None = ...,
+        user: str | None = ...,
+        extra_body: dict[str, Any] | None = ...,
+    ) -> Stream[ChatCompletionChunk]: ...
+
+    def create(
+        self,
+        *,
+        messages: list[dict[str, Any]],
+        model: str = "normal",
+        stream: bool = False,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        stop: str | list[str] | None = None,
+        presence_penalty: float | None = None,
+        frequency_penalty: float | None = None,
+        user: str | None = None,
+        extra_body: dict[str, Any] | None = None,
+    ) -> ChatCompletion | Stream[ChatCompletionChunk]:
+        if self._client.api_key:
+            return self._paid_create(
+                messages=messages,
+                model=model,
+                stream=stream,
+                max_tokens=max_tokens,
+                temperature=temperature,
+                top_p=top_p,
+                stop=stop,
+                presence_penalty=presence_penalty,
+                frequency_penalty=frequency_penalty,
+                user=user,
+                extra_body=extra_body,
+            )
+
+        return self._free_create(
+            messages=messages,
+            model=model,
+            stream=stream,
+            max_tokens=max_tokens,
+            extra_body=extra_body,
+        )
+
+    def _resolve_free(self, model: str) -> tuple[str, str]:
+        key = model.strip().lower()
+
+        if key in FREE_PRESETS:
+            return FREE_PRESETS[key]
+
+        return model, "normal"
+
+    def _free_create(
+        self,
+        *,
+        messages: list[dict[str, Any]],
+        model: str,
+        stream: bool,
+        max_tokens: int | None,
+        extra_body: dict[str, Any] | None,
+    ) -> ChatCompletion | Stream[ChatCompletionChunk]:
+        model_id, preset = self._resolve_free(model)
+
+        content = ""
+
+        history: list[dict[str, Any]] = []
+
+        for msg in messages:
+            role = str(msg.get("role") or "user")
+
+            text = msg.get("content")
+
+            if text is None:
+                continue
+
+            if not isinstance(text, str):
+                text = str(text)
+
+            if role == "system":
+                continue
+
+            if role == "user":
+                content = text
+
+            history.append(
+                {
+                    "id": str(uuid.uuid4()),
+                    "role": role,
+                    "content": text,
+                }
+            )
+
+        if history and history[-1]["role"] == "user":
+            history = history[:-1]
+
+        if not content and messages:
+            last = messages[-1].get("content")
+
+            content = last if isinstance(last, str) else str(last or "")
+
+        turn_id = str(uuid.uuid4())
+
+        body: dict[str, Any] = {
+            "turnId": turn_id,
+            "model": model_id,
+            "mode": "free",
+            "preset": preset,
+            "message": {
+                "id": str(uuid.uuid4()),
+                "role": "user",
+                "content": content,
+            },
+            "history": history,
+        }
+
+        if max_tokens is not None:
+            body["maxTokens"] = max_tokens
+
+        if extra_body:
+            body.update(extra_body)
+
+        url = f"{CHAT_BASE}/api/chat/send"
+
+        headers = self._client._chat_headers()
+
+        headers["Accept"] = "text/event-stream"
+
+        if stream:
+            return Stream(self._iter_free_stream(url, body, headers, model_id, turn_id))
+
+        text_parts: list[str] = []
+
+        reasoning_parts: list[str] = []
+
+        request_id = turn_id
+
+        for event in self._iter_sse(url, body, headers):
+            etype = event.get("type")
+
+            if etype == "start":
+                request_id = str(event.get("requestId") or request_id)
+
+            elif etype == "delta":
+                chunk = event.get("text")
+
+                if chunk:
+                    text_parts.append(str(chunk))
+
+                reason = event.get("reasoning")
+
+                if reason:
+                    reasoning_parts.append(str(reason))
+
+            elif etype == "done":
+                break
+
+        created = int(time.time())
+
+        message = ChatCompletionMessage(
+            role="assistant",
+            content="".join(text_parts),
+            reasoning="".join(reasoning_parts) or None,
+        )
+
+        return ChatCompletion(
+            id=str(request_id),
+            choices=[Choice(index=0, message=message, finish_reason="stop")],
+            created=created,
+            model=model_id,
+        )
+
+    def _iter_free_stream(
+        self,
+        url: str,
+        body: dict[str, Any],
+        headers: dict[str, str],
+        model_id: str,
+        turn_id: str,
+    ) -> Iterator[ChatCompletionChunk]:
+        created = int(time.time())
+
+        request_id = turn_id
+
+        for event in self._iter_sse(url, body, headers):
+            etype = event.get("type")
+
+            if etype == "start":
+                request_id = str(event.get("requestId") or request_id)
+
+                yield ChatCompletionChunk(
+                    id=str(request_id),
+                    choices=[
+                        ChunkChoice(
+                            index=0,
+                            delta=ChoiceDelta(role="assistant", content=""),
+                        )
+                    ],
+                    created=created,
+                    model=model_id,
+                )
+
+            elif etype == "delta":
+                text = event.get("text")
+
+                reason = event.get("reasoning")
+
+                if not text and not reason:
+                    continue
+
+                yield ChatCompletionChunk(
+                    id=str(request_id),
+                    choices=[
+                        ChunkChoice(
+                            index=0,
+                            delta=ChoiceDelta(
+                                content=str(text) if text else None,
+                                reasoning=str(reason) if reason else None,
+                            ),
+                        )
+                    ],
+                    created=created,
+                    model=model_id,
+                )
+
+            elif etype == "done":
+                yield ChatCompletionChunk(
+                    id=str(request_id),
+                    choices=[
+                        ChunkChoice(
+                            index=0,
+                            delta=ChoiceDelta(),
+                            finish_reason="stop",
+                        )
+                    ],
+                    created=created,
+                    model=model_id,
+                )
+
+                break
+
+    def _iter_sse(
+        self,
+        url: str,
+        body: dict[str, Any],
+        headers: dict[str, str],
+    ) -> Iterator[dict[str, Any]]:
+        buf = b""
+
+        for chunk in self._client._http.stream("POST", url, json_body=body, headers=headers):
+            buf += chunk
+
+            while b"\n" in buf:
+                line, buf = buf.split(b"\n", 1)
+
+                line = line.strip()
+
+                if not line or line.startswith(b":"):
+                    continue
+
+                if line.startswith(b"data:"):
+                    payload = line[5:].strip()
+
+                    if payload == b"[DONE]":
+                        return
+
+                    try:
+                        yield orjson.loads(payload)
+                    except Exception:
+                        continue
+
+    def _paid_create(
+        self,
+        *,
+        messages: list[dict[str, Any]],
+        model: str,
+        stream: bool,
+        max_tokens: int | None,
+        temperature: float | None,
+        top_p: float | None,
+        stop: str | list[str] | None,
+        presence_penalty: float | None,
+        frequency_penalty: float | None,
+        user: str | None,
+        extra_body: dict[str, Any] | None,
+    ) -> ChatCompletion | Stream[ChatCompletionChunk]:
+        model_id, _ = self._resolve_free(model)
+
+        body: dict[str, Any] = {
+            "model": model_id,
+            "messages": messages,
+            "stream": stream,
+        }
+
+        if max_tokens is not None:
+            body["max_tokens"] = max_tokens
+
+        if temperature is not None:
+            body["temperature"] = temperature
+
+        if top_p is not None:
+            body["top_p"] = top_p
+
+        if stop is not None:
+            body["stop"] = stop
+
+        if presence_penalty is not None:
+            body["presence_penalty"] = presence_penalty
+
+        if frequency_penalty is not None:
+            body["frequency_penalty"] = frequency_penalty
+
+        if user is not None:
+            body["user"] = user
+
+        if extra_body:
+            body.update(extra_body)
+
+        url = f"{self._client.base_url.rstrip('/')}/chat/completions"
+
+        headers = self._client._auth_headers()
+
+        if stream:
+            return Stream(self._iter_paid_stream(url, body, headers, model_id))
+
+        resp = self._client._http.request(
+            "POST",
+            url,
+            json_body=body,
+            headers=headers,
+        )
+
+        if resp.status_code >= 400:
+            self._client._http.raise_for_status(resp.status_code, resp.content)
+
+        data = self._client._http.parse_json(resp) or {}
+
+        return self._parse_completion(data, fallback_model=model_id)
+
+    def _iter_paid_stream(
+        self,
+        url: str,
+        body: dict[str, Any],
+        headers: dict[str, str],
+        model_id: str,
+    ) -> Iterator[ChatCompletionChunk]:
+        headers = {**headers, "Accept": "text/event-stream"}
+
+        created = int(time.time())
+
+        for event in self._iter_sse(url, body, headers):
+            if event.get("object") == "chat.completion.chunk" or "choices" in event:
+                choices_in = event.get("choices") or []
+
+                choices: list[ChunkChoice] = []
+
+                for i, ch in enumerate(choices_in):
+                    delta = ch.get("delta") or {}
+
+                    choices.append(
+                        ChunkChoice(
+                            index=int(ch.get("index") or i),
+                            delta=ChoiceDelta(
+                                role=delta.get("role"),
+                                content=delta.get("content"),
+                            ),
+                            finish_reason=ch.get("finish_reason"),
+                        )
+                    )
+
+                yield ChatCompletionChunk(
+                    id=str(event.get("id") or ""),
+                    choices=choices,
+                    created=int(event.get("created") or created),
+                    model=str(event.get("model") or model_id),
+                )
+
+                continue
+
+            etype = event.get("type")
+
+            if etype == "delta" and event.get("text"):
+                yield ChatCompletionChunk(
+                    id=str(event.get("requestId") or ""),
+                    choices=[
+                        ChunkChoice(
+                            index=0,
+                            delta=ChoiceDelta(content=str(event.get("text"))),
+                        )
+                    ],
+                    created=created,
+                    model=model_id,
+                )
+
+    def _parse_completion(self, data: dict[str, Any], *, fallback_model: str) -> ChatCompletion:
+        choices: list[Choice] = []
+
+        for i, ch in enumerate(data.get("choices") or []):
+            msg = ch.get("message") or {}
+
+            choices.append(
+                Choice(
+                    index=int(ch.get("index") or i),
+                    message=ChatCompletionMessage(
+                        role=str(msg.get("role") or "assistant"),
+                        content=msg.get("content"),
+                    ),
+                    finish_reason=ch.get("finish_reason"),
+                )
+            )
+
+        usage = None
+
+        raw_usage = data.get("usage")
+
+        if isinstance(raw_usage, dict):
+            usage = CompletionUsage(
+                prompt_tokens=int(raw_usage.get("prompt_tokens") or 0),
+                completion_tokens=int(raw_usage.get("completion_tokens") or 0),
+                total_tokens=int(raw_usage.get("total_tokens") or 0),
+            )
+
+        return ChatCompletion(
+            id=str(data.get("id") or ""),
+            choices=choices,
+            created=int(data.get("created") or time.time()),
+            model=str(data.get("model") or fallback_model),
+            usage=usage,
+            system_fingerprint=data.get("system_fingerprint"),
+        )
+
+
+class Chat:
+    __slots__ = ("completions",)
+
+    def __init__(self, client: URouter) -> None:
+        self.completions = Completions(client)

urouter_sdk-0.1.0/urouter/resources/models.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from urouter._constants import API_BASE, CHAT_BASE
+from urouter._types import Model, ModelList
+
+if TYPE_CHECKING:
+    from urouter._client import URouter
+
+
+class Models:
+    __slots__ = ("_client",)
+
+    def __init__(self, client: URouter) -> None:
+        self._client = client
+
+    def list(self) -> ModelList:
+        if self._client.api_key:
+            url = f"{self._client.base_url.rstrip('/')}/models"
+
+            resp = self._client._http.request(
+                "GET",
+                url,
+                headers=self._client._auth_headers(),
+            )
+
+            if resp.status_code >= 400:
+                self._client._http.raise_for_status(resp.status_code, resp.content)
+
+            payload = self._client._http.parse_json(resp) or {}
+
+            items = []
+
+            for row in payload.get("data") or []:
+                items.append(
+                    Model(
+                        id=str(row.get("id") or ""),
+                        name=row.get("name"),
+                        brand=row.get("brand"),
+                        owned_by=str(row.get("brand") or row.get("owned_by") or "urouter"),
+                        raw=row if isinstance(row, dict) else {},
+                    )
+                )
+
+            return ModelList(data=items)
+
+        resp = self._client._http.request(
+            "GET",
+            f"{CHAT_BASE}/api/chat/state",
+            headers=self._client._chat_headers(),
+        )
+
+        if resp.status_code >= 400:
+            self._client._http.raise_for_status(resp.status_code, resp.content)
+
+        payload = self._client._http.parse_json(resp) or {}
+
+        items = []
+
+        for row in payload.get("models") or []:
+            mid = str(row.get("id") or "")
+
+            items.append(
+                Model(
+                    id=mid,
+                    name=mid,
+                    owned_by="urouter",
+                    raw=row if isinstance(row, dict) else {},
+                )
+            )
+
+        for row in payload.get("presets") or []:
+            mid = str(row.get("modelId") or row.get("id") or "")
+
+            if mid and not any(m.id == mid for m in items):
+                items.append(
+                    Model(
+                        id=mid,
+                        name=str(row.get("label") or mid),
+                        owned_by="urouter-free",
+                        raw=row if isinstance(row, dict) else {},
+                    )
+                )
+
+        return ModelList(data=items)
+
+    def retrieve(self, model: str) -> Model:
+        if self._client.api_key:
+            url = f"{self._client.base_url.rstrip('/')}/models/{model}"
+
+            resp = self._client._http.request(
+                "GET",
+                url,
+                headers=self._client._auth_headers(),
+            )
+
+            if resp.status_code >= 400:
+                self._client._http.raise_for_status(resp.status_code, resp.content)
+
+            row: dict[str, Any] = self._client._http.parse_json(resp) or {}
+
+            return Model(
+                id=str(row.get("id") or model),
+                name=row.get("name"),
+                brand=row.get("brand"),
+                owned_by=str(row.get("brand") or "urouter"),
+                raw=row,
+            )
+
+        listed = self.list()
+
+        for item in listed.data:
+            if item.id == model:
+                return item
+
+        return Model(id=model, owned_by="urouter")