forked from retoor/devplacepy
Add openai_gateway/apps.py as the single list of internal gateway apps and send X-OpenRouter-Title (plus legacy X-Title and HTTP-Referer) per app to every upstream. Label the Devii agent, bots, modifier, quiz grading, SEO metadata, community and sync callers. Shorten two app references that exceeded the 30 character limit and were recorded as default. Also includes the pending Muse Code, route health and Responses work. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
807 lines
26 KiB
Python
807 lines
26 KiB
Python
# retoor <retoor@molodetz.nl>
|
|
|
|
import pytest
|
|
from pydantic import ValidationError
|
|
|
|
from devplacepy.services.openai_gateway import routing as r
|
|
from devplacepy.services.openai_gateway.usage import pricing_from_cfg
|
|
from tests.conftest import run_async
|
|
|
|
|
|
class _FakeModelsResponse:
|
|
def __init__(self, status_code, payload=None):
|
|
self.status_code = status_code
|
|
self._payload = payload
|
|
|
|
def json(self):
|
|
return self._payload
|
|
|
|
|
|
class _FakeModelsClient:
|
|
def __init__(self, status_code, payload=None, error=None):
|
|
self.status_code = status_code
|
|
self.payload = payload
|
|
self.error = error
|
|
self.requested_url = None
|
|
self.headers = None
|
|
|
|
async def __aenter__(self):
|
|
return self
|
|
|
|
async def __aexit__(self, *exc_info):
|
|
return False
|
|
|
|
async def get(self, url):
|
|
self.requested_url = url
|
|
if self.error is not None:
|
|
raise self.error
|
|
return _FakeModelsResponse(self.status_code, self.payload)
|
|
|
|
|
|
def _patch_stealth_client(monkeypatch, fake_client):
|
|
def _factory(**kwargs):
|
|
fake_client.headers = kwargs.get("headers")
|
|
return fake_client
|
|
|
|
monkeypatch.setattr("devplacepy.stealth.stealth_async_client", _factory)
|
|
|
|
|
|
def _cleanup(providers, models):
|
|
for name in providers:
|
|
r.provider_store.remove(name)
|
|
for source in models:
|
|
r.model_store.remove(source)
|
|
|
|
|
|
def test_no_routes_pass_through(local_db):
|
|
assert r.chat_overlay("ghost-model-xyz", {}) is None
|
|
assert r.embed_overlay("ghost-embed-xyz", {}) is None
|
|
assert r.image_overlay("ghost-image-xyz", {}) is None
|
|
|
|
|
|
def test_chat_route_overlay_and_economy(local_db):
|
|
r.provider_store.set(
|
|
r.ProviderIn(
|
|
name="utor",
|
|
base_url="https://up.example/v1/chat/completions",
|
|
api_key="k1",
|
|
)
|
|
)
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="ut-chat",
|
|
provider="utor",
|
|
target_model="vendor/big",
|
|
kind="chat",
|
|
context_window=64000,
|
|
price_cache_hit_per_m=1.0,
|
|
price_cache_miss_per_m=2.0,
|
|
price_output_per_m=8.0,
|
|
)
|
|
)
|
|
try:
|
|
overlay = r.chat_overlay("ut-chat", {"gateway_model_context_map": "{}"})
|
|
assert overlay["gateway_force_model"] is True
|
|
assert overlay["gateway_model"] == "vendor/big"
|
|
assert overlay["gateway_upstream_url"] == "https://up.example/v1/chat/completions"
|
|
assert overlay["gateway_api_key"] == "k1"
|
|
assert overlay["gateway_price_output_per_m"] == 8.0
|
|
assert overlay["gateway_model_context_map"]["vendor/big"] == 64000
|
|
pricing = pricing_from_cfg(overlay)
|
|
assert pricing.chat_output_per_m == 8.0
|
|
assert pricing.chat_cache_miss_per_m == 2.0
|
|
finally:
|
|
_cleanup(["utor"], ["ut-chat"])
|
|
|
|
|
|
def test_resolve_fallback_returns_none_without_a_configured_fallback(local_db):
|
|
r.model_store.set(r.ModelRouteIn(source_model="fb-primary", target_model="v/a"))
|
|
try:
|
|
assert r.resolve_fallback("fb-primary", "chat") is None
|
|
finally:
|
|
_cleanup([], ["fb-primary"])
|
|
|
|
|
|
def test_resolve_fallback_returns_none_for_an_unknown_source(local_db):
|
|
assert r.resolve_fallback("ghost-fb-source", "chat") is None
|
|
|
|
|
|
def test_resolve_fallback_rejects_self_reference(local_db):
|
|
with pytest.raises(ValidationError):
|
|
r.ModelRouteIn(
|
|
source_model="fb-self", target_model="v/a", fallback_model="fb-self"
|
|
)
|
|
|
|
|
|
def test_resolve_fallback_returns_the_configured_route(local_db):
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="fb-backup", target_model="v/backup", kind="chat"
|
|
)
|
|
)
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="fb-primary",
|
|
target_model="v/primary",
|
|
kind="chat",
|
|
fallback_model="fb-backup",
|
|
)
|
|
)
|
|
try:
|
|
fallback = r.resolve_fallback("fb-primary", "chat")
|
|
assert fallback is not None
|
|
assert fallback.source_model == "fb-backup"
|
|
assert fallback.target_model == "v/backup"
|
|
finally:
|
|
_cleanup([], ["fb-primary", "fb-backup"])
|
|
|
|
|
|
def test_resolve_fallback_ignores_an_inactive_fallback_route(local_db):
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="fb-backup-off",
|
|
target_model="v/backup",
|
|
kind="chat",
|
|
is_active=False,
|
|
)
|
|
)
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="fb-primary-2",
|
|
target_model="v/primary",
|
|
kind="chat",
|
|
fallback_model="fb-backup-off",
|
|
)
|
|
)
|
|
try:
|
|
assert r.resolve_fallback("fb-primary-2", "chat") is None
|
|
finally:
|
|
_cleanup([], ["fb-primary-2", "fb-backup-off"])
|
|
|
|
|
|
def test_resolve_fallback_ignores_a_fallback_of_a_different_kind(local_db):
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="fb-backup-embed", target_model="v/e", kind="embed"
|
|
)
|
|
)
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="fb-primary-3",
|
|
target_model="v/primary",
|
|
kind="chat",
|
|
fallback_model="fb-backup-embed",
|
|
)
|
|
)
|
|
try:
|
|
assert r.resolve_fallback("fb-primary-3", "chat") is None
|
|
finally:
|
|
_cleanup([], ["fb-primary-3", "fb-backup-embed"])
|
|
|
|
|
|
def _chain_route(source, target, fallback="", active=True):
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model=source,
|
|
target_model=target,
|
|
kind="chat",
|
|
fallback_model=fallback,
|
|
is_active=active,
|
|
)
|
|
)
|
|
|
|
|
|
def _mark_health(source, status):
|
|
from devplacepy.services.openai_gateway import health
|
|
|
|
code = "" if status == "ok" else "http_500"
|
|
message = "" if status == "ok" else "boom"
|
|
health.record_health(
|
|
source, health.ProbeResult(status == "ok", code, message, 1.0)
|
|
)
|
|
|
|
|
|
def test_fallback_chain_skips_bad_and_inactive_links(local_db):
|
|
_chain_route("chain-a", "v/a", "chain-b")
|
|
_chain_route("chain-b", "v/b", "chain-c")
|
|
_chain_route("chain-c", "v/c", "chain-d")
|
|
_chain_route("chain-d", "v/d", "", active=False)
|
|
_mark_health("chain-b", "bad")
|
|
try:
|
|
line = r.resolve_fallback_chain("chain-a", "chat")
|
|
assert [m.source_model for m in line] == ["chain-c"]
|
|
finally:
|
|
_cleanup([], ["chain-a", "chain-b", "chain-c", "chain-d"])
|
|
|
|
|
|
def test_fallback_chain_stops_on_cycles(local_db):
|
|
_chain_route("chain-e", "v/e", "chain-f")
|
|
_chain_route("chain-f", "v/f", "chain-e")
|
|
try:
|
|
line = r.resolve_fallback_chain("chain-e", "chat")
|
|
assert [m.source_model for m in line] == ["chain-f"]
|
|
finally:
|
|
_cleanup([], ["chain-e", "chain-f"])
|
|
|
|
|
|
def test_fallback_chain_respects_max_hops(local_db):
|
|
names = [f"chain-h{i}" for i in range(8)]
|
|
for pos, name in enumerate(names):
|
|
nxt = names[pos + 1] if pos + 1 < len(names) else ""
|
|
_chain_route(name, f"v/{name}", nxt)
|
|
try:
|
|
line = r.resolve_fallback_chain(names[0], "chat", max_hops=3)
|
|
assert [m.source_model for m in line] == names[1:4]
|
|
assert len(r.resolve_fallback_chain(names[0], "chat")) <= 5
|
|
finally:
|
|
_cleanup([], names)
|
|
|
|
|
|
def test_entry_route_preroutes_bad_models(local_db):
|
|
_chain_route("chain-g", "v/g", "chain-h")
|
|
_chain_route("chain-h", "v/h")
|
|
_mark_health("chain-g", "bad")
|
|
try:
|
|
assert r.resolve_entry_route("chain-g", "chat").source_model == "chain-h"
|
|
assert r.resolve_entry_route("chain-h", "chat").source_model == "chain-h"
|
|
assert r.resolve_entry_route("ghost-entry", "chat") is None
|
|
finally:
|
|
_cleanup([], ["chain-g", "chain-h"])
|
|
|
|
|
|
def test_entry_route_falls_back_to_original_when_line_is_empty(local_db):
|
|
_chain_route("chain-i", "v/i", "chain-j")
|
|
_chain_route("chain-j", "v/j")
|
|
_mark_health("chain-i", "bad")
|
|
_mark_health("chain-j", "bad")
|
|
try:
|
|
assert r.resolve_entry_route("chain-i", "chat").source_model == "chain-i"
|
|
finally:
|
|
_cleanup([], ["chain-i", "chain-j"])
|
|
|
|
|
|
def test_vision_merge_overlay(local_db):
|
|
r.provider_store.set(
|
|
r.ProviderIn(
|
|
name="utvis",
|
|
base_url="https://vis.example/v1/chat/completions",
|
|
api_key="vk",
|
|
)
|
|
)
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="ut-vision",
|
|
provider="utvis",
|
|
target_model="vendor/vlm",
|
|
kind="chat",
|
|
vision_model="vendor/describe",
|
|
price_input_per_m=0.5,
|
|
)
|
|
)
|
|
try:
|
|
overlay = r.chat_overlay("ut-vision", {})
|
|
assert overlay["gateway_vision_enabled"] is True
|
|
assert overlay["gateway_vision_model"] == "vendor/describe"
|
|
assert overlay["gateway_vision_url"] == "https://vis.example/v1/chat/completions"
|
|
assert overlay["gateway_vision_key"] == "vk"
|
|
assert overlay["gateway_vision_price_input_per_m"] == 0.5
|
|
finally:
|
|
_cleanup(["utvis"], ["ut-vision"])
|
|
|
|
|
|
def test_image_route_and_kind_isolation(local_db):
|
|
r.provider_store.set(
|
|
r.ProviderIn(
|
|
name="utimg",
|
|
base_url="https://img.example/v1/chat/completions",
|
|
api_key="ik",
|
|
)
|
|
)
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="ut-image",
|
|
provider="utimg",
|
|
target_model="vendor/flux",
|
|
kind="image",
|
|
price_input_per_m=0.05,
|
|
)
|
|
)
|
|
try:
|
|
overlay = r.image_overlay("ut-image", {})
|
|
assert overlay["gateway_image_model"] == "vendor/flux"
|
|
assert overlay["gateway_image_url"] == "https://img.example/v1/images"
|
|
assert overlay["gateway_image_key"] == "ik"
|
|
assert overlay["gateway_image_price_per_call"] == 0.05
|
|
assert r.chat_overlay("ut-image", {}) is None
|
|
assert r.embed_overlay("ut-image", {}) is None
|
|
pricing = pricing_from_cfg(overlay)
|
|
assert pricing.image_per_call == 0.05
|
|
finally:
|
|
_cleanup(["utimg"], ["ut-image"])
|
|
|
|
|
|
def test_embed_route_and_kind_isolation(local_db):
|
|
r.provider_store.set(
|
|
r.ProviderIn(
|
|
name="utemb",
|
|
base_url="https://emb.example/v1/chat/completions",
|
|
api_key="ek",
|
|
)
|
|
)
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="ut-embed",
|
|
provider="utemb",
|
|
target_model="vendor/embed",
|
|
kind="embed",
|
|
price_input_per_m=0.13,
|
|
)
|
|
)
|
|
try:
|
|
overlay = r.embed_overlay("ut-embed", {})
|
|
assert overlay["gateway_embed_model"] == "vendor/embed"
|
|
assert overlay["gateway_embed_url"] == "https://emb.example/v1/embeddings"
|
|
assert overlay["gateway_embed_key"] == "ek"
|
|
assert overlay["gateway_embed_price_input_per_m"] == 0.13
|
|
assert r.chat_overlay("ut-embed", {}) is None
|
|
finally:
|
|
_cleanup(["utemb"], ["ut-embed"])
|
|
|
|
|
|
def test_embed_overlay_blank_provider_key_preserves_top_level_key(local_db):
|
|
r.provider_store.set(
|
|
r.ProviderIn(
|
|
name="utemblank",
|
|
base_url="https://emb.example/v1/chat/completions",
|
|
api_key="",
|
|
)
|
|
)
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="ut-embed-blank",
|
|
provider="utemblank",
|
|
target_model="vendor/embed",
|
|
kind="embed",
|
|
)
|
|
)
|
|
try:
|
|
base_cfg = {"gateway_embed_key": "top-level-fallback-key"}
|
|
overlay = r.embed_overlay("ut-embed-blank", base_cfg)
|
|
assert "gateway_embed_key" not in overlay
|
|
merged = {**base_cfg, **overlay}
|
|
assert merged["gateway_embed_key"] == "top-level-fallback-key"
|
|
finally:
|
|
_cleanup(["utemblank"], ["ut-embed-blank"])
|
|
|
|
|
|
def test_inactive_route_ignored(local_db):
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="ut-off",
|
|
target_model="vendor/x",
|
|
kind="chat",
|
|
is_active=False,
|
|
)
|
|
)
|
|
try:
|
|
assert r.chat_overlay("ut-off", {}) is None
|
|
finally:
|
|
_cleanup([], ["ut-off"])
|
|
|
|
|
|
def test_blank_provider_uses_default_upstream(local_db):
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="ut-default",
|
|
target_model="vendor/def",
|
|
kind="chat",
|
|
price_output_per_m=3.0,
|
|
)
|
|
)
|
|
try:
|
|
overlay = r.chat_overlay("ut-default", {})
|
|
assert overlay["gateway_model"] == "vendor/def"
|
|
assert "gateway_upstream_url" not in overlay
|
|
assert "gateway_api_key" not in overlay
|
|
assert overlay["gateway_price_output_per_m"] == 3.0
|
|
finally:
|
|
_cleanup([], ["ut-default"])
|
|
|
|
|
|
def test_provider_with_a_client_profile_gets_extra_headers(local_db):
|
|
r.provider_store.set(
|
|
r.ProviderIn(
|
|
name="zen",
|
|
base_url="https://opencode.ai/zen/v1/chat/completions",
|
|
api_key="public",
|
|
client_profile="opencode",
|
|
)
|
|
)
|
|
r.model_store.set(
|
|
r.ModelRouteIn(source_model="ut-zen", provider="zen", target_model="kimi-k3")
|
|
)
|
|
try:
|
|
overlay = r.chat_overlay("ut-zen", {})
|
|
headers = overlay["gateway_extra_request_headers"]
|
|
assert headers["x-opencode-client"]
|
|
assert "User-Agent" in headers
|
|
finally:
|
|
_cleanup(["zen"], ["ut-zen"])
|
|
|
|
|
|
def test_provider_without_a_client_profile_gets_no_extra_headers(local_db):
|
|
r.provider_store.set(
|
|
r.ProviderIn(name="plainprov", base_url="https://up.example/v1/chat/completions")
|
|
)
|
|
r.model_store.set(
|
|
r.ModelRouteIn(source_model="ut-plain", provider="plainprov", target_model="vendor/x")
|
|
)
|
|
try:
|
|
overlay = r.chat_overlay("ut-plain", {})
|
|
assert "gateway_extra_request_headers" not in overlay
|
|
finally:
|
|
_cleanup(["plainprov"], ["ut-plain"])
|
|
|
|
|
|
def test_provider_with_a_muse_profile_gets_muse_headers(local_db):
|
|
r.provider_store.set(
|
|
r.ProviderIn(
|
|
name="meta",
|
|
base_url="https://api.meta.ai/v1/responses",
|
|
api_key="secret",
|
|
client_profile="muse",
|
|
)
|
|
)
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="ut-muse",
|
|
provider="meta",
|
|
target_model="muse-spark",
|
|
)
|
|
)
|
|
try:
|
|
overlay = r.chat_overlay("ut-muse", {})
|
|
headers = overlay["gateway_extra_request_headers"]
|
|
assert headers["X-Client-Id"] == "tbh:exec"
|
|
assert headers["User-Agent"].startswith("muse-build/")
|
|
finally:
|
|
_cleanup(["meta"], ["ut-muse"])
|
|
|
|
|
|
def test_client_profile_rejects_unknown_value():
|
|
with pytest.raises(ValidationError):
|
|
r.ProviderIn(name="badprofile", client_profile="not-a-real-profile")
|
|
|
|
|
|
def test_tier2_and_off_peak_fields_propagate_through_overlay(local_db):
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="ut-tiered",
|
|
target_model="vendor/tiered",
|
|
kind="chat",
|
|
price_cache_hit_per_m=0.0028,
|
|
price_cache_miss_per_m=0.14,
|
|
price_output_per_m=0.28,
|
|
context_tier_threshold_tokens=128_000,
|
|
price_output_per_m_tier2=0.56,
|
|
off_peak_start_minute=990,
|
|
off_peak_end_minute=30,
|
|
off_peak_discount_pct=25.0,
|
|
)
|
|
)
|
|
try:
|
|
overlay = r.chat_overlay("ut-tiered", {})
|
|
assert overlay["gateway_context_tier_threshold_tokens"] == 128_000
|
|
assert overlay["gateway_price_output_per_m_tier2"] == 0.56
|
|
assert overlay["gateway_price_cache_hit_per_m_tier2"] is None
|
|
assert overlay["gateway_off_peak_start_minute"] == 990
|
|
assert overlay["gateway_off_peak_end_minute"] == 30
|
|
assert overlay["gateway_off_peak_discount_pct"] == 25.0
|
|
pricing = pricing_from_cfg(overlay)
|
|
assert pricing.context_tier_threshold_tokens == 128_000
|
|
assert pricing.chat_output_per_m_tier2 == 0.56
|
|
assert pricing.chat_cache_hit_per_m_tier2 is None
|
|
assert pricing.off_peak_start_minute == 990
|
|
finally:
|
|
_cleanup([], ["ut-tiered"])
|
|
|
|
|
|
def test_unrouted_request_never_gains_tier_or_off_peak_keys(local_db):
|
|
assert r.chat_overlay("ghost-model-untiered", {}) is None
|
|
pricing = pricing_from_cfg({})
|
|
assert pricing.context_tier_threshold_tokens == 0
|
|
assert pricing.off_peak_start_minute is None
|
|
assert pricing.off_peak_end_minute is None
|
|
assert pricing.chat_output_per_m_tier2 is None
|
|
|
|
|
|
def test_off_peak_window_requires_both_start_and_end():
|
|
with pytest.raises(ValidationError):
|
|
r.ModelRouteIn(
|
|
source_model="ut-bad-window",
|
|
target_model="vendor/x",
|
|
off_peak_start_minute=60,
|
|
)
|
|
with pytest.raises(ValidationError):
|
|
r.ModelRouteIn(
|
|
source_model="ut-bad-window",
|
|
target_model="vendor/x",
|
|
off_peak_end_minute=120,
|
|
)
|
|
|
|
|
|
def test_seed_default_image_routes_is_idempotent(local_db):
|
|
r.model_store.remove(r.IMAGE_SOURCE_MODEL)
|
|
r.seed_default_image_routes()
|
|
route = r.model_store.get(r.IMAGE_SOURCE_MODEL)
|
|
assert route is not None
|
|
assert route.kind == "image"
|
|
assert route.target_model == r.FLUX_TARGET_MODEL
|
|
r.seed_default_image_routes()
|
|
assert r.model_store.get(r.IMAGE_SOURCE_MODEL).target_model == r.FLUX_TARGET_MODEL
|
|
|
|
|
|
def test_seed_default_deepseek_routes_is_idempotent_and_preserves_customization(
|
|
local_db,
|
|
):
|
|
r.seed_default_deepseek_routes()
|
|
flash = r.model_store.get("deepseek-v4-flash")
|
|
pro = r.model_store.get("deepseek-v4-pro")
|
|
assert flash is not None and pro is not None
|
|
assert flash.price_cache_hit_per_m == 0.0028
|
|
assert flash.price_cache_miss_per_m == 0.14
|
|
assert flash.price_output_per_m == 0.28
|
|
assert flash.context_window == 1_048_576
|
|
assert pro.price_cache_hit_per_m == 0.003625
|
|
assert pro.price_cache_miss_per_m == 0.435
|
|
assert pro.price_output_per_m == 0.87
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="deepseek-v4-pro",
|
|
target_model="deepseek-v4-pro",
|
|
price_output_per_m=1.23,
|
|
)
|
|
)
|
|
try:
|
|
r.seed_default_deepseek_routes()
|
|
assert r.model_store.get("deepseek-v4-pro").price_output_per_m == 1.23
|
|
finally:
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="deepseek-v4-pro",
|
|
target_model="deepseek-v4-pro",
|
|
price_cache_hit_per_m=0.003625,
|
|
price_cache_miss_per_m=0.435,
|
|
price_output_per_m=0.87,
|
|
context_window=1_048_576,
|
|
)
|
|
)
|
|
|
|
|
|
def test_seed_publishes_molodetz_aliases(local_db):
|
|
r.seed_default_deepseek_routes()
|
|
try:
|
|
molodetz = r.model_store.resolve("molodetz", "chat")
|
|
molodetz_pro = r.model_store.resolve("molodetz-pro", "chat")
|
|
assert molodetz is not None
|
|
assert molodetz.target_model == "deepseek-v4-flash"
|
|
assert molodetz_pro is not None
|
|
assert molodetz_pro.target_model == "deepseek-v4-pro"
|
|
sources = {row["source_model"] for row in r.model_store.list()}
|
|
assert {"molodetz", "molodetz-pro"} <= sources
|
|
finally:
|
|
r.model_store.remove("molodetz")
|
|
r.model_store.remove("molodetz-pro")
|
|
|
|
|
|
def test_models_url_from_base_swaps_chat_completions():
|
|
assert (
|
|
r._models_url_from_base("https://x.example/v1/chat/completions")
|
|
== "https://x.example/v1/models"
|
|
)
|
|
|
|
|
|
def test_models_url_from_base_appends_when_no_chat_completions_suffix():
|
|
assert r._models_url_from_base("https://x.example/v1") == "https://x.example/v1/models"
|
|
assert r._models_url_from_base("https://x.example/v1/") == "https://x.example/v1/models"
|
|
|
|
|
|
def test_models_url_from_base_blank_is_blank():
|
|
assert r._models_url_from_base("") == ""
|
|
assert r._models_url_from_base(" ") == ""
|
|
|
|
|
|
def test_fetch_provider_models_returns_ids_on_success(local_db, monkeypatch):
|
|
r.provider_store.set(
|
|
r.ProviderIn(
|
|
name="probeprov",
|
|
base_url="https://x.example/v1/chat/completions",
|
|
api_key="sk-probe",
|
|
)
|
|
)
|
|
fake_client = _FakeModelsClient(200, {"data": [{"id": "vendor/a"}, {"id": "vendor/b"}]})
|
|
_patch_stealth_client(monkeypatch, fake_client)
|
|
try:
|
|
models = run_async(r.fetch_provider_models("probeprov"))
|
|
assert models == ["vendor/a", "vendor/b"]
|
|
assert fake_client.requested_url == "https://x.example/v1/models"
|
|
assert fake_client.headers == {"authorization": "Bearer sk-probe"}
|
|
finally:
|
|
r.provider_store.remove("probeprov")
|
|
|
|
|
|
def test_fetch_provider_models_uses_default_provider_when_blank(local_db, monkeypatch):
|
|
monkeypatch.setattr(
|
|
r,
|
|
"_default_provider_credentials",
|
|
lambda: ("https://default.example/v1/chat/completions", "sk-default"),
|
|
)
|
|
fake_client = _FakeModelsClient(200, {"data": [{"id": "default/model"}]})
|
|
_patch_stealth_client(monkeypatch, fake_client)
|
|
models = run_async(r.fetch_provider_models(""))
|
|
assert models == ["default/model"]
|
|
assert fake_client.requested_url == "https://default.example/v1/models"
|
|
|
|
|
|
def test_fetch_provider_models_none_for_unknown_provider(local_db):
|
|
assert run_async(r.fetch_provider_models("no-such-provider")) is None
|
|
|
|
|
|
def test_fetch_provider_models_none_on_non_200(local_db, monkeypatch):
|
|
r.provider_store.set(
|
|
r.ProviderIn(name="probeprov404", base_url="https://x.example/v1/chat/completions")
|
|
)
|
|
fake_client = _FakeModelsClient(404, {})
|
|
_patch_stealth_client(monkeypatch, fake_client)
|
|
try:
|
|
assert run_async(r.fetch_provider_models("probeprov404")) is None
|
|
finally:
|
|
r.provider_store.remove("probeprov404")
|
|
|
|
|
|
def test_fetch_provider_models_none_on_malformed_payload(local_db, monkeypatch):
|
|
r.provider_store.set(
|
|
r.ProviderIn(name="probeprovbad", base_url="https://x.example/v1/chat/completions")
|
|
)
|
|
fake_client = _FakeModelsClient(200, {"not_data": []})
|
|
_patch_stealth_client(monkeypatch, fake_client)
|
|
try:
|
|
assert run_async(r.fetch_provider_models("probeprovbad")) is None
|
|
finally:
|
|
r.provider_store.remove("probeprovbad")
|
|
|
|
|
|
def test_fetch_provider_models_none_on_empty_list(local_db, monkeypatch):
|
|
r.provider_store.set(
|
|
r.ProviderIn(name="probeprovempty", base_url="https://x.example/v1/chat/completions")
|
|
)
|
|
fake_client = _FakeModelsClient(200, {"data": []})
|
|
_patch_stealth_client(monkeypatch, fake_client)
|
|
try:
|
|
assert run_async(r.fetch_provider_models("probeprovempty")) is None
|
|
finally:
|
|
r.provider_store.remove("probeprovempty")
|
|
|
|
|
|
def test_fetch_provider_models_none_on_network_error(local_db, monkeypatch):
|
|
r.provider_store.set(
|
|
r.ProviderIn(name="probeprovdown", base_url="https://x.example/v1/chat/completions")
|
|
)
|
|
fake_client = _FakeModelsClient(200, error=RuntimeError("connection refused"))
|
|
_patch_stealth_client(monkeypatch, fake_client)
|
|
try:
|
|
assert run_async(r.fetch_provider_models("probeprovdown")) is None
|
|
finally:
|
|
r.provider_store.remove("probeprovdown")
|
|
|
|
|
|
def test_fetch_provider_models_none_when_provider_has_no_base_url(local_db):
|
|
r.provider_store.set(r.ProviderIn(name="probeprovnourl", base_url=""))
|
|
try:
|
|
assert run_async(r.fetch_provider_models("probeprovnourl")) is None
|
|
finally:
|
|
r.provider_store.remove("probeprovnourl")
|
|
|
|
|
|
def test_provider_protocol_defaults_and_validates(local_db):
|
|
assert r.ProviderIn(name="p1").protocol == "chat_completions"
|
|
assert r.ProviderIn(name="p1", protocol="responses").protocol == "responses"
|
|
assert r.ProviderIn(name="p1", protocol=" Responses ").protocol == "responses"
|
|
with pytest.raises(ValidationError):
|
|
r.ProviderIn(name="p1", protocol="soap")
|
|
|
|
|
|
def test_provider_protocol_round_trips_through_store(local_db):
|
|
r.provider_store.set(
|
|
r.ProviderIn(
|
|
name="protometa",
|
|
base_url="https://api.meta.ai/v1/responses",
|
|
api_key="sk-test",
|
|
protocol="responses",
|
|
)
|
|
)
|
|
try:
|
|
saved = r.provider_store.get("protometa")
|
|
assert saved is not None
|
|
assert saved["protocol"] == "responses"
|
|
assert saved["base_url"] == "https://api.meta.ai/v1/responses"
|
|
finally:
|
|
r.provider_store.remove("protometa")
|
|
|
|
|
|
def test_chat_overlay_carries_provider_protocol(local_db):
|
|
r.provider_store.set(
|
|
r.ProviderIn(
|
|
name="protoovl",
|
|
base_url="https://api.meta.ai/v1/responses",
|
|
api_key="sk-test",
|
|
protocol="responses",
|
|
)
|
|
)
|
|
r.model_store.set(
|
|
r.ModelRouteIn(
|
|
source_model="meta-route",
|
|
provider="protoovl",
|
|
target_model="muse-spark-1.3-contributor",
|
|
kind="chat",
|
|
)
|
|
)
|
|
try:
|
|
overlay = r.chat_overlay("meta-route", {"gateway_model": "x"})
|
|
assert overlay["gateway_upstream_protocol"] == "responses"
|
|
assert (
|
|
overlay["gateway_upstream_url"]
|
|
== "https://api.meta.ai/v1/responses"
|
|
)
|
|
finally:
|
|
_cleanup(["protoovl"], ["meta-route"])
|
|
|
|
|
|
def test_responses_models_urls_probe_both_shapes():
|
|
assert r._responses_models_urls("https://api.meta.ai/v1/responses") == [
|
|
"https://api.meta.ai/v1/models",
|
|
"https://api.meta.ai/v1/muse-code/models",
|
|
]
|
|
assert r._responses_models_urls("") == []
|
|
|
|
|
|
def test_fetch_provider_models_tries_meta_listing_second(local_db, monkeypatch):
|
|
r.provider_store.set(
|
|
r.ProviderIn(
|
|
name="probeprovmeta",
|
|
base_url="https://api.meta.ai/v1/responses",
|
|
protocol="responses",
|
|
)
|
|
)
|
|
|
|
class _SeqClient:
|
|
def __init__(self):
|
|
self.requested_urls = []
|
|
|
|
async def __aenter__(self):
|
|
return self
|
|
|
|
async def __aexit__(self, *exc_info):
|
|
return False
|
|
|
|
async def get(self, url):
|
|
self.requested_urls.append(url)
|
|
if url == "https://api.meta.ai/v1/models":
|
|
return _FakeModelsResponse(404, {})
|
|
return _FakeModelsResponse(
|
|
200, {"data": [{"id": "muse-spark-1.3-contributor"}]}
|
|
)
|
|
|
|
fake_client = _SeqClient()
|
|
_patch_stealth_client(monkeypatch, fake_client)
|
|
try:
|
|
assert run_async(r.fetch_provider_models("probeprovmeta")) == [
|
|
"muse-spark-1.3-contributor"
|
|
]
|
|
assert fake_client.requested_urls == [
|
|
"https://api.meta.ai/v1/models",
|
|
"https://api.meta.ai/v1/muse-code/models",
|
|
]
|
|
finally:
|
|
r.provider_store.remove("probeprovmeta")
|