clean up

routstr/proxy.py

@@ -1,9 +1,8 @@
 import json
-from pathlib import Path
 from typing import Any
 
 from fastapi import APIRouter, Depends, HTTPException, Request
-from fastapi.responses import HTMLResponse, JSONResponse, Response, StreamingResponse
+from fastapi.responses import Response, StreamingResponse
 from sqlmodel import select
 
 from .algorithm import create_model_mappings
@@ -151,51 +150,10 @@ async def refresh_model_maps_periodically() -> None:
             )
 
 
-_API_PATH_PREFIXES = ("v1/", "responses")
-
-_NOT_FOUND_HTML_FILE = Path(__file__).parent.parent / "ui_out" / "404.html"
-
-
-def _read_not_found_html() -> str | None:
-    try:
-        return _NOT_FOUND_HTML_FILE.read_text(encoding="utf-8")
-    except OSError:
-        return None
-
-
-_NOT_FOUND_HTML: str | None = _read_not_found_html()
-
-
-def _build_not_found_response(request: Request, path: str) -> Response:
-    """Return a 404 for unknown paths.
-    """
-    accept = request.headers.get("accept", "").lower()
-    prefers_json = "application/json" in accept and "text/html" not in accept
-    request_id = getattr(request.state, "request_id", "unknown")
-
-    if not prefers_json and _NOT_FOUND_HTML is not None:
-        return HTMLResponse(content=_NOT_FOUND_HTML, status_code=404)
-
-    return JSONResponse(
-        status_code=404,
-        content={
-            "error": {
-                "message": f"Path '/{path}' not found",
-                "type": "not_found",
-                "code": 404,
-            },
-            "request_id": request_id,
-        },
-    )
-
-
 @proxy_router.api_route("/{path:path}", methods=["GET", "POST"], response_model=None)
 async def proxy(
     request: Request, path: str, session: AsyncSession = Depends(get_session)
 ) -> Response | StreamingResponse:
-    if not path.startswith(_API_PATH_PREFIXES):
-        return _build_not_found_response(request, path)
-
     headers = dict(request.headers)
 
     is_responses_api = path.startswith("v1/responses") or path.startswith("responses")

routstr/upstream/base.py

@@ -42,22 +42,12 @@ from ..payment.models import (
 from ..payment.price import sats_usd_price
 from ..wallet import recieve_token, send_token
 from . import messages_dispatch
+from .count_tokens import count_tokens_locally
 from .litellm_routing import detect_litellm_prefix
 
 logger = get_logger(__name__)
 
 
-def _is_json_content_type(content_type: str | None) -> bool:
-    """Return True when the upstream response should be parsed as JSON.
-    """
-    if not content_type:
-        return False
-    main = content_type.split(";", 1)[0].strip().lower()
-    if main in ("application/json", "text/json"):
-        return True
-    return main.startswith("application/") and main.endswith("+json")
-
-
 class TopupData(BaseModel):
     """Universal top-up data schema for Lightning Network invoices."""
 
@@ -534,8 +524,7 @@ class BaseUpstreamProvider:
     async def forward_upstream_error_response(
         self, request: Request, path: str, upstream_response: httpx.Response
     ) -> Response:
-        """Log upstream errors and forward the response in a JSON envelope.
-        """
+        """Log upstream errors and forward the upstream response unchanged."""
         status_code = upstream_response.status_code
         headers = dict(upstream_response.headers)
         content_type = headers.get("content-type") or headers.get("Content-Type", "")
@@ -557,10 +546,9 @@ class BaseUpstreamProvider:
 
         message, upstream_code = self._extract_upstream_error_message(body_bytes)
         body_preview = body_bytes.decode("utf-8", errors="ignore").strip()[:500]
-        is_json_body = _is_json_content_type(content_type)
 
         logger.warning(
-            "Forwarding upstream error response",
+            "Forwarding upstream error response as-is",
             extra={
                 "path": path,
                 "provider": self.provider_type,
@@ -572,7 +560,6 @@ class BaseUpstreamProvider:
                 "body_preview": body_preview,
                 "body_read_error": body_read_error,
                 "method": request.method,
-                "json_normalized": not is_json_body,
             },
         )
 
@@ -600,40 +587,17 @@ class BaseUpstreamProvider:
         ):
             headers.pop(header_name, None)
 
-        if is_json_body:
-            if not content_type:
-                headers.pop("content-type", None)
-                headers.pop("Content-Type", None)
-            media_type = content_type or None
-            return Response(
-                content=body_bytes,
-                status_code=status_code,
-                headers=headers,
-                media_type=media_type,
-            )
+        if not content_type:
+            headers.pop("content-type", None)
+            headers.pop("Content-Type", None)
 
-        # Non-JSON upstream error (HTML, plain text, empty, ...). Wrap it in
-        # the standard JSON envelope so callers don't need a second parser.
-        for header_name in ("content-type", "Content-Type"):
-            headers.pop(header_name, None)
-
-        envelope = {
-            "error": {
-                "message": message or "Upstream returned a non-JSON error response",
-                "type": "upstream_error",
-                "code": upstream_code or status_code,
-                "upstream_status": status_code,
-                "upstream_content_type": content_type or None,
-                "upstream_body_preview": body_preview or None,
-            },
-            "request_id": getattr(request.state, "request_id", None),
-        }
+        media_type = content_type or None
 
         return Response(
-            content=json.dumps(envelope).encode(),
+            content=body_bytes,
             status_code=status_code,
             headers=headers,
-            media_type="application/json",
+            media_type=media_type,
         )
 
     async def handle_streaming_chat_completion(
@@ -2196,6 +2160,12 @@ class BaseUpstreamProvider:
         """
         path = self.normalize_request_path(path, model_obj)
 
+        if (
+            path.endswith("messages/count_tokens")
+            and not self.supports_anthropic_messages
+        ):
+            return count_tokens_locally(request_body, model_obj)
+
         if (
             path.endswith("messages")
             and not path.endswith("count_tokens")
@@ -3394,6 +3364,12 @@ class BaseUpstreamProvider:
 
         request_body = await request.body()
 
+        if (
+            path.endswith("messages/count_tokens")
+            and not self.supports_anthropic_messages
+        ):
+            return count_tokens_locally(request_body, model_obj)
+
         if (
             path.endswith("messages")
             and not path.endswith("count_tokens")

routstr/upstream/count_tokens.py

@@ -0,0 +1,108 @@
+"""Local handling of Anthropic ``/v1/messages/count_tokens`` for upstreams
+that do not natively expose the endpoint.
+
+Most non-Anthropic upstreams (OpenAI-compat, Gemini OpenAI-compat,
+OpenRouter chat-completions, generic providers) return 400/404 when asked
+to ``POST /messages/count_tokens``. Claude Code and other Anthropic SDK
+clients call this endpoint before each turn to size context windows and
+trigger compaction, so a failure breaks the whole chat.
+
+We answer locally. ``litellm.token_counter`` understands the Anthropic
+message shape and the per-model tokenizers, so we prefer it. If it raises
+(unknown model, encoding lookup failure, ...), we fall back to the
+project's own ``estimate_tokens`` heuristic, which is always defined and
+never raises.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import litellm
+from fastapi.responses import Response
+
+from ..core import get_logger
+from ..payment.helpers import estimate_tokens
+from ..payment.models import Model
+
+logger = get_logger(__name__)
+
+
+def _parse_request_body(request_body: bytes | None) -> dict[str, Any]:
+    if not request_body:
+        return {}
+    try:
+        parsed = json.loads(request_body)
+    except (ValueError, TypeError):
+        return {}
+    return parsed if isinstance(parsed, dict) else {}
+
+
+def _count_with_litellm(model: str, body: dict[str, Any]) -> int:
+    messages = body.get("messages")
+    if not isinstance(messages, list):
+        messages = []
+
+    system = body.get("system")
+    if isinstance(system, str) and system:
+        messages = [{"role": "system", "content": system}, *messages]
+    elif isinstance(system, list):
+        text = "".join(
+            block.get("text", "")
+            for block in system
+            if isinstance(block, dict) and block.get("type") == "text"
+        )
+        if text:
+            messages = [{"role": "system", "content": text}, *messages]
+
+    tools = body.get("tools") if isinstance(body.get("tools"), list) else None
+
+    return int(
+        litellm.token_counter(
+            model=model,
+            messages=messages,
+            tools=tools,
+        )
+    )
+
+
+def count_tokens_locally(
+    request_body: bytes | None,
+    model_obj: Model | None,
+) -> Response:
+    """Return an Anthropic-compatible count_tokens response without
+    touching the upstream. Always returns 200; never raises."""
+    body = _parse_request_body(request_body)
+
+    model_name = ""
+    if model_obj is not None:
+        model_name = model_obj.forwarded_model_id or model_obj.id or ""
+    if not model_name:
+        body_model = body.get("model")
+        if isinstance(body_model, str):
+            model_name = body_model
+
+    input_tokens: int
+    try:
+        input_tokens = _count_with_litellm(model_name, body)
+    except Exception as exc:
+        messages = body.get("messages")
+        fallback_messages = messages if isinstance(messages, list) else []
+        input_tokens = estimate_tokens(fallback_messages)
+        logger.debug(
+            "litellm token_counter failed; using local estimator",
+            extra={
+                "model": model_name,
+                "error": str(exc),
+                "error_type": type(exc).__name__,
+                "estimated_tokens": input_tokens,
+            },
+        )
+
+    payload = {"input_tokens": max(0, int(input_tokens))}
+    return Response(
+        content=json.dumps(payload).encode(),
+        status_code=200,
+        media_type="application/json",
+    )

routstr/upstream/routstr.py

@@ -18,10 +18,6 @@ class RoutstrUpstreamProvider(BaseUpstreamProvider):
     provider_type = "routstr"
     default_base_url = None
     platform_url = None
-    # Upstream Routstr nodes serve `/v1/messages` natively, so forward the
-    # request as-is instead of round-tripping through litellm's
-    # Anthropic→OpenAI translator.
-    supports_anthropic_messages = True
 
     def __init__(
         self,
@@ -47,13 +43,6 @@ class RoutstrUpstreamProvider(BaseUpstreamProvider):
         )
         self.settings = provider_settings or {}
 
-    def normalize_request_path(
-        self, path: str, model_obj: "Model | None" = None
-    ) -> str:
-        """Preserve the ``v1/`` prefix when forwarding to an upstream Routstr.
-        """
-        return path.lstrip("/")
-
     @classmethod
     def from_db_row(
         cls, provider_row: "UpstreamProviderRow"

routstr/wallet.py

@@ -48,8 +48,6 @@ async def recieve_token(
     if token_obj.mint not in settings.cashu_mints:
         return await swap_to_primary_mint(token_obj, wallet)
 
-    await wallet.load_mint(keyset_id=token_obj.keysets[0])
-
     wallet.verify_proofs_dleq(token_obj.proofs)
     await wallet.split(proofs=token_obj.proofs, amount=0, include_fees=True)
 

tests/unit/test_count_tokens_local.py

@@ -0,0 +1,177 @@
+"""Unit tests for the local count_tokens shim.
+
+The shim runs whenever an upstream that does not support Anthropic's
+``/v1/messages`` endpoint is asked for a token count. It must always
+return a 200 JSON ``{"input_tokens": N}`` response and must never raise.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+from unittest.mock import patch
+
+from routstr.payment.models import Architecture, Model, Pricing
+from routstr.upstream import count_tokens as count_tokens_module
+from routstr.upstream.count_tokens import count_tokens_locally
+
+
+def _make_model(model_id: str = "anthropic/claude-3-5-sonnet") -> Model:
+    pricing = Pricing(prompt=0.000003, completion=0.000015)
+    architecture = Architecture(
+        modality="text",
+        input_modalities=["text"],
+        output_modalities=["text"],
+        tokenizer="cl100k_base",
+        instruct_type=None,
+    )
+    return Model(
+        id=model_id,
+        name=model_id,
+        created=0,
+        description="",
+        context_length=200_000,
+        architecture=architecture,
+        pricing=pricing,
+    )
+
+
+def _body(payload: dict[str, Any]) -> bytes:
+    return json.dumps(payload).encode()
+
+
+def _read_payload(response: Any) -> dict[str, Any]:
+    body = response.body if isinstance(response.body, bytes) else bytes(response.body)
+    return json.loads(body.decode())
+
+
+def test_returns_input_tokens_for_simple_messages() -> None:
+    model = _make_model()
+    request_body = _body(
+        {
+            "model": model.id,
+            "messages": [{"role": "user", "content": "hello world"}],
+        }
+    )
+
+    response = count_tokens_locally(request_body, model)
+
+    assert response.status_code == 200
+    assert response.media_type == "application/json"
+    payload = _read_payload(response)
+    assert "input_tokens" in payload
+    assert isinstance(payload["input_tokens"], int)
+    assert payload["input_tokens"] >= 0
+
+
+def test_falls_back_to_estimator_when_litellm_raises() -> None:
+    model = _make_model()
+    request_body = _body(
+        {
+            "model": model.id,
+            "messages": [{"role": "user", "content": "this is a longer message"}],
+        }
+    )
+
+    with patch.object(
+        count_tokens_module,
+        "_count_with_litellm",
+        side_effect=RuntimeError("boom"),
+    ):
+        response = count_tokens_locally(request_body, model)
+
+    assert response.status_code == 200
+    payload = _read_payload(response)
+    assert payload["input_tokens"] >= 1
+
+
+def test_handles_missing_model_object() -> None:
+    request_body = _body(
+        {
+            "model": "anthropic/claude-3-5-sonnet",
+            "messages": [{"role": "user", "content": "hi"}],
+        }
+    )
+
+    response = count_tokens_locally(request_body, None)
+
+    assert response.status_code == 200
+    payload = _read_payload(response)
+    assert payload["input_tokens"] >= 0
+
+
+def test_handles_empty_request_body() -> None:
+    response = count_tokens_locally(b"", _make_model())
+
+    assert response.status_code == 200
+    payload = _read_payload(response)
+    assert payload["input_tokens"] >= 0
+
+
+def test_handles_malformed_json() -> None:
+    response = count_tokens_locally(b"not-json", _make_model())
+
+    assert response.status_code == 200
+    payload = _read_payload(response)
+    assert payload["input_tokens"] >= 0
+
+
+def test_includes_system_prompt_in_count() -> None:
+    model = _make_model()
+    short = _body(
+        {
+            "model": model.id,
+            "messages": [{"role": "user", "content": "hi"}],
+        }
+    )
+    with_system = _body(
+        {
+            "model": model.id,
+            "system": "You are a helpful assistant with a long preamble " * 10,
+            "messages": [{"role": "user", "content": "hi"}],
+        }
+    )
+
+    short_count = _read_payload(count_tokens_locally(short, model))["input_tokens"]
+    long_count = _read_payload(count_tokens_locally(with_system, model))["input_tokens"]
+
+    assert long_count > short_count
+
+
+def test_supports_anthropic_system_block_list() -> None:
+    model = _make_model()
+    request_body = _body(
+        {
+            "model": model.id,
+            "system": [{"type": "text", "text": "be terse" * 50}],
+            "messages": [{"role": "user", "content": "ok"}],
+        }
+    )
+
+    response = count_tokens_locally(request_body, model)
+
+    payload = _read_payload(response)
+    assert payload["input_tokens"] > 0
+
+
+def test_uses_forwarded_model_id_when_present() -> None:
+    model = _make_model("anthropic/claude-3-5-sonnet")
+    model.forwarded_model_id = "claude-3-5-sonnet-20241022"
+    request_body = _body(
+        {
+            "model": "ignored",
+            "messages": [{"role": "user", "content": "hi"}],
+        }
+    )
+
+    captured: dict[str, Any] = {}
+
+    def _capture(model_name: str, body: dict[str, Any]) -> int:
+        captured["model"] = model_name
+        return 7
+
+    with patch.object(count_tokens_module, "_count_with_litellm", side_effect=_capture):
+        response = count_tokens_locally(request_body, model)
+
+    assert captured["model"] == "claude-3-5-sonnet-20241022"
+    assert _read_payload(response)["input_tokens"] == 7

tests/unit/test_messages_litellm_dispatch.py

@@ -908,7 +908,7 @@ async def test_forward_request_skips_litellm_when_provider_supports_messages() -
 
 
 @pytest.mark.asyncio
-async def test_forward_request_skips_litellm_for_count_tokens() -> None:
+async def test_forward_request_handles_count_tokens_locally() -> None:
     provider = _make_provider()
     key = _make_key()
     model = _make_model()
@@ -923,19 +923,25 @@ async def test_forward_request_skips_litellm_for_count_tokens() -> None:
         with patch.object(
             provider,
             "prepare_request_body",
-            side_effect=RuntimeError("stop here"),
+            side_effect=AssertionError("upstream should not be called"),
         ):
-            with pytest.raises(RuntimeError, match="stop here"):
-                await provider.forward_request(
-                    request=request,
-                    path="messages/count_tokens",
-                    headers={},
-                    request_body=_anthropic_request_body(),
-                    key=key,
-                    max_cost_for_model=10_000,
-                    session=session,
-                    model_obj=model,
-                )
+            response = await provider.forward_request(
+                request=request,
+                path="messages/count_tokens",
+                headers={},
+                request_body=_anthropic_request_body(),
+                key=key,
+                max_cost_for_model=10_000,
+                session=session,
+                model_obj=model,
+            )
+
+    assert response.status_code == 200
+    body = response.body if isinstance(response.body, bytes) else bytes(response.body)
+    payload = json.loads(body.decode())
+    assert "input_tokens" in payload
+    assert isinstance(payload["input_tokens"], int)
+    assert payload["input_tokens"] >= 0
 
 
 # ---------------------------------------------------------------------------
@@ -1010,7 +1016,7 @@ async def test_forward_x_cashu_request_skips_litellm_when_native_messages() -> N
 
 
 @pytest.mark.asyncio
-async def test_forward_x_cashu_request_skips_litellm_for_count_tokens() -> None:
+async def test_forward_x_cashu_request_handles_count_tokens_locally() -> None:
     provider = _make_provider()
     model = _make_model()
     request = _make_request()
@@ -1024,18 +1030,24 @@ async def test_forward_x_cashu_request_skips_litellm_for_count_tokens() -> None:
         with patch.object(
             provider,
             "prepare_request_body",
-            side_effect=RuntimeError("stop here"),
+            side_effect=AssertionError("upstream should not be called"),
         ):
-            with pytest.raises(RuntimeError, match="stop here"):
-                await provider.forward_x_cashu_request(
-                    request=request,
-                    path="v1/messages/count_tokens",
-                    headers={},
-                    amount=5_000,
-                    unit="sat",
-                    max_cost_for_model=10_000,
-                    model_obj=model,
-                )
+            response = await provider.forward_x_cashu_request(
+                request=request,
+                path="v1/messages/count_tokens",
+                headers={},
+                amount=5_000,
+                unit="sat",
+                max_cost_for_model=10_000,
+                model_obj=model,
+                mint="https://mint",
+                payment_token_hash="h",
+            )
+
+    assert response.status_code == 200
+    body = response.body if isinstance(response.body, bytes) else bytes(response.body)
+    payload = json.loads(body.decode())
+    assert "input_tokens" in payload
 
 
 # ---------------------------------------------------------------------------

tests/unit/test_proxy_not_found.py

@@ -1,64 +0,0 @@
-"""Tests for the built-in 404 handler in routstr.proxy."""
-
-from __future__ import annotations
-
-import pytest
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-
-from routstr import proxy
-from routstr.proxy import proxy_router
-
-
-def _make_app() -> FastAPI:
-    app = FastAPI()
-    app.include_router(proxy_router)
-    return app
-
-
-@pytest.mark.skipif(
-    proxy._NOT_FOUND_HTML is None,
-    reason="UI bundle (ui_out/404.html) not present in this environment",
-)
-def test_unknown_path_returns_html_404_for_browser() -> None:
-    client = TestClient(_make_app())
-    response = client.get("/some/random/page", headers={"accept": "text/html"})
-    assert response.status_code == 404
-    assert response.headers["content-type"].startswith("text/html")
-    assert "404" in response.text
-
-
-def test_unknown_path_returns_json_404_for_api_client() -> None:
-    client = TestClient(_make_app())
-    response = client.get(
-        "/some/random/page", headers={"accept": "application/json"}
-    )
-    assert response.status_code == 404
-    assert response.headers["content-type"].startswith("application/json")
-    payload = response.json()
-    assert payload["error"]["type"] == "not_found"
-    assert payload["error"]["code"] == 404
-    assert "/some/random/page" in payload["error"]["message"]
-
-
-def test_root_path_returns_404_for_proxy_router() -> None:
-    client = TestClient(_make_app())
-    response = client.get("/", headers={"accept": "application/json"})
-    assert response.status_code == 404
-
-
-def test_v1_path_is_not_intercepted_by_404_handler() -> None:
-    """Paths starting with v1/ must reach the proxy logic, not the 404 handler."""
-    client = TestClient(_make_app(), raise_server_exceptions=False)
-    response = client.get("/v1/anything")
-    if response.status_code == 404:
-        # Any 404 here must come from inner proxy logic, not our HTML page.
-        assert "<!DOCTYPE html>" not in response.text
-
-
-def test_json_returned_when_ui_html_missing(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setattr(proxy, "_NOT_FOUND_HTML", None)
-    client = TestClient(_make_app())
-    response = client.get("/some/random/page", headers={"accept": "text/html"})
-    assert response.status_code == 404
-    assert response.headers["content-type"].startswith("application/json")

tests/unit/test_upstream_error_response.py

@@ -1,150 +0,0 @@
-"""Tests for ``BaseUpstreamProvider.forward_upstream_error_response``.
-
-Upstream services (e.g. an Express server that doesn't expose ``/messages``)
-sometimes return a non-JSON error body. The proxy must surface those errors
-in a consistent JSON envelope so clients don't have to parse HTML.
-"""
-
-from __future__ import annotations
-
-import json
-from typing import Any
-from unittest.mock import Mock
-
-import httpx
-import pytest
-
-from routstr.upstream.base import BaseUpstreamProvider, _is_json_content_type
-
-
-def _make_request(request_id: str = "req-123") -> Mock:
-    request = Mock(spec=["method", "state"])
-    request.method = "POST"
-    request.state = Mock()
-    request.state.request_id = request_id
-    return request
-
-
-def _make_upstream_response(
-    *,
-    body: bytes,
-    status_code: int = 404,
-    content_type: str | None = "text/html",
-    extra_headers: dict[str, str] | None = None,
-) -> httpx.Response:
-    headers: dict[str, str] = {}
-    if content_type is not None:
-        headers["content-type"] = content_type
-    if extra_headers:
-        headers.update(extra_headers)
-    return httpx.Response(status_code=status_code, headers=headers, content=body)
-
-
-@pytest.fixture
-def provider() -> BaseUpstreamProvider:
-    return BaseUpstreamProvider(
-        base_url="https://privateprovider.xyz", api_key="k", provider_fee=1.0
-    )
-
-
-@pytest.mark.parametrize(
-    "content_type,expected",
-    [
-        ("application/json", True),
-        ("application/json; charset=utf-8", True),
-        ("text/json", True),
-        ("application/problem+json", True),
-        ("application/vnd.api+json", True),
-        ("text/html", False),
-        ("text/html; charset=utf-8", False),
-        ("text/plain", False),
-        ("", False),
-        (None, False),
-    ],
-)
-def test_is_json_content_type(content_type: str | None, expected: bool) -> None:
-    assert _is_json_content_type(content_type) is expected
-
-
-@pytest.mark.asyncio
-async def test_html_error_is_normalized_to_json_envelope(
-    provider: BaseUpstreamProvider,
-) -> None:
-    html_body = (
-        b"<!DOCTYPE html><html><head><title>Error</title></head>"
-        b"<body><pre>Cannot POST /messages</pre></body></html>"
-    )
-    upstream = _make_upstream_response(body=html_body, status_code=404)
-
-    response = await provider.forward_upstream_error_response(
-        _make_request(), "v1/messages", upstream
-    )
-
-    assert response.status_code == 404
-    assert response.media_type == "application/json"
-    payload: dict[str, Any] = json.loads(bytes(response.body))
-    assert payload["error"]["type"] == "upstream_error"
-    assert payload["error"]["upstream_status"] == 404
-    assert payload["error"]["upstream_content_type"] == "text/html"
-    assert "Cannot POST /messages" in payload["error"]["upstream_body_preview"]
-    assert payload["request_id"] == "req-123"
-    # The upstream's text/html content-type must not survive — Response()
-    # sets the JSON content-type for us via media_type.
-    assert response.headers["content-type"].startswith("application/json")
-
-
-@pytest.mark.asyncio
-async def test_plain_text_error_is_normalized(
-    provider: BaseUpstreamProvider,
-) -> None:
-    upstream = _make_upstream_response(
-        body=b"Service Unavailable", status_code=503, content_type="text/plain"
-    )
-
-    response = await provider.forward_upstream_error_response(
-        _make_request(), "v1/messages", upstream
-    )
-
-    assert response.status_code == 503
-    assert response.media_type == "application/json"
-    payload = json.loads(bytes(response.body))
-    assert payload["error"]["message"] == "Service Unavailable"
-
-
-@pytest.mark.asyncio
-async def test_empty_body_with_non_json_content_type_normalizes(
-    provider: BaseUpstreamProvider,
-) -> None:
-    upstream = _make_upstream_response(
-        body=b"", status_code=502, content_type="text/html"
-    )
-
-    response = await provider.forward_upstream_error_response(
-        _make_request(), "v1/messages", upstream
-    )
-
-    assert response.status_code == 502
-    assert response.media_type == "application/json"
-    payload = json.loads(bytes(response.body))
-    assert payload["error"]["type"] == "upstream_error"
-    assert payload["error"]["upstream_body_preview"] is None
-
-
-@pytest.mark.asyncio
-async def test_json_error_body_is_passed_through_unchanged(
-    provider: BaseUpstreamProvider,
-) -> None:
-    json_body = json.dumps(
-        {"error": {"message": "Invalid model", "type": "invalid_request_error"}}
-    ).encode()
-    upstream = _make_upstream_response(
-        body=json_body, status_code=400, content_type="application/json"
-    )
-
-    response = await provider.forward_upstream_error_response(
-        _make_request(), "v1/messages", upstream
-    )
-
-    assert response.status_code == 400
-    assert bytes(response.body) == json_body
-    assert response.media_type == "application/json"

tests/unit/test_upstream_routstr.py

@@ -74,39 +74,3 @@ async def test_get_balance_returns_none_on_connect_timeout(
     balance = await provider.get_balance()
 
     assert balance is None
-
-
-def test_normalize_request_path_keeps_v1_prefix() -> None:
-    """Routstr upstream stores ``base_url`` without ``/v1``; the prefix
-    must stay on the path so ``build_request_url`` produces ``/v1/<endpoint>``
-    instead of ``/<endpoint>`` (which the upstream Routstr 404s with HTML)."""
-    provider = RoutstrUpstreamProvider(
-        base_url="https://privateprovider.xyz", api_key="key"
-    )
-
-    assert provider.normalize_request_path("v1/messages") == "v1/messages"
-    assert provider.normalize_request_path("/v1/messages") == "v1/messages"
-    assert (
-        provider.normalize_request_path("v1/chat/completions")
-        == "v1/chat/completions"
-    )
-
-
-def test_build_request_url_for_v1_messages() -> None:
-    """Forwarding ``/v1/messages`` must hit the upstream's ``/v1/messages``."""
-    provider = RoutstrUpstreamProvider(
-        base_url="https://privateprovider.xyz", api_key="key"
-    )
-
-    normalized = provider.normalize_request_path("v1/messages")
-
-    assert (
-        provider.build_request_url(normalized)
-        == "https://privateprovider.xyz/v1/messages"
-    )
-
-
-def test_supports_anthropic_messages_natively() -> None:
-    """Routstr nodes serve ``/v1/messages`` directly, so the proxy must
-    forward as-is instead of round-tripping through litellm."""
-    assert RoutstrUpstreamProvider.supports_anthropic_messages is True