Send per-app provider attribution titles from one gateway app registry

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>
This commit is contained in:
2026-11-04 18:45:09 +01:00
co-authored by Claude Sonnet 5.5
parent ec30ed408c
commit bc11475f29
31 changed files with 2198 additions and 208 deletions
+1 -1
View File
@@ -10,7 +10,7 @@ def test_generate_requests_the_preamble_bypass(local_db, monkeypatch):
seen = {}
def fake_gateway_complete(
api_key, system, text, timeout, model=None, bypass_preamble=False
api_key, system, text, timeout, model=None, bypass_preamble=False, app_reference=None
):
seen["bypass_preamble"] = bypass_preamble
return (
@@ -0,0 +1,43 @@
# retoor <retoor@molodetz.nl>
from devplacepy import config as devplace_config
from devplacepy.services.openai_gateway.apps import (
APP_REFERENCE_PATTERN,
GATEWAY_APPS,
LEGACY_TITLE_HEADER,
REFERER_HEADER,
TITLE_HEADER,
app_title,
attribution_headers,
)
def test_every_registered_reference_is_valid_and_unique():
references = [app.reference for app in GATEWAY_APPS]
assert len(references) == len(set(references))
for reference in references:
assert APP_REFERENCE_PATTERN.match(reference), reference
def test_title_is_per_app():
assert app_title("devplace-devii-v-1-0-0") == "DevPlace Devii"
assert app_title("devplace-news-v-1-0-0") == "DevPlace News"
def test_unknown_and_default_fall_back_to_platform_title():
assert app_title("default") == "DevPlace"
assert app_title("someone-else") == "DevPlace"
assert app_title("") == "DevPlace"
def test_attribution_headers_carry_both_title_names(monkeypatch):
monkeypatch.setattr(devplace_config, "SITE_URL", "https://devplace.net")
headers = attribution_headers("devplace-bots-v-1-0-0")
assert headers[TITLE_HEADER] == "DevPlace Bots"
assert headers[LEGACY_TITLE_HEADER] == "DevPlace Bots"
assert headers[REFERER_HEADER] == "https://devplace.net"
def test_referer_omitted_without_site_url(monkeypatch):
monkeypatch.setattr(devplace_config, "SITE_URL", "")
assert REFERER_HEADER not in attribution_headers("default")
+470 -2
View File
@@ -66,10 +66,11 @@ class FakeResp_openai_gateway:
yield frame(usage=payload["usage"])
yield "data: [DONE]"
class FakeRequest:
def __init__(self, method, url, json_body):
def __init__(self, method, url, json_body, headers=None):
self.method = method
self.url = url
self.json_body = json_body
self.headers = headers or {}
self.extensions = {}
class FakeClient_openai_gateway:
def __init__(self, *a, **k):
@@ -948,6 +949,194 @@ def test_chat_falls_back_when_the_primary_model_fails(local_db, monkeypatch):
routing.model_store.remove("fb-backup-route")
class FakeChainClient_openai_gateway:
def __init__(self, *a, **k):
self.calls = []
def build_request(self, method, url, headers=None, json=None, content=None):
return FakeRequest(method, url, json)
async def send(self, request, stream=False):
self.calls.append((request.url, request.json_body))
body = request.json_body or {}
model = body.get("model")
if model in ("chain-a-target", "chain-b-target"):
return FakeResp_openai_gateway(status=500, payload={"error": "boom"})
return FakeResp_openai_gateway(
payload={
"id": "x",
"model": model,
"choices": [{"message": {"content": "chain ok"}}],
}
)
async def aclose(self):
pass
def test_chat_walks_fallback_chain_past_failures(local_db, monkeypatch):
from devplacepy.services.openai_gateway import routing
monkeypatch.setattr(gwmod.httpx, "AsyncClient", FakeChainClient_openai_gateway)
routing.model_store.set(
routing.ModelRouteIn(source_model="chain-c", target_model="chain-c-target")
)
routing.model_store.set(
routing.ModelRouteIn(
source_model="chain-b",
target_model="chain-b-target",
fallback_model="chain-c",
)
)
routing.model_store.set(
routing.ModelRouteIn(
source_model="chain-a",
target_model="chain-a-target",
fallback_model="chain-b",
)
)
try:
svc = GatewayService()
cfg = svc.effective_config()
cfg["gateway_vision_enabled"] = False
cfg["gateway_max_retries"] = 0
rt = svc.runtime()
response = run_async(
rt.handle_chat(
{"model": "chain-a", "messages": [{"role": "user", "content": "hi"}]},
cfg,
("guest", "chain_walk"),
"test",
"default",
)
)
assert response.status_code == 200
assert [c[1]["model"] for c in rt._client.calls] == [
"chain-a-target",
"chain-b-target",
"chain-c-target",
]
row = get_table("gateway_usage_ledger").find_one(owner_id="chain_walk")
assert row["model"] == "chain-c-target"
assert row["fallback_used_route"] == "chain-c"
finally:
routing.model_store.remove("chain-a")
routing.model_store.remove("chain-b")
routing.model_store.remove("chain-c")
def test_chat_preroutes_around_unhealthy_models(local_db, monkeypatch):
from devplacepy.services.openai_gateway import health, routing
monkeypatch.setattr(gwmod.httpx, "AsyncClient", FakeClient_openai_gateway)
routing.model_store.set(
routing.ModelRouteIn(source_model="pre-good", target_model="good-target")
)
routing.model_store.set(
routing.ModelRouteIn(
source_model="pre-bad",
target_model="bad-target",
fallback_model="pre-good",
)
)
health.record_health(
"pre-bad", health.ProbeResult(False, "http_500", "boom", 1.0)
)
try:
svc = GatewayService()
cfg = svc.effective_config()
cfg["gateway_vision_enabled"] = False
rt = svc.runtime()
logged = []
response = run_async(
rt.handle_chat(
{"model": "pre-bad", "messages": [{"role": "user", "content": "hi"}]},
cfg,
("guest", "preroute"),
"test",
"default",
log=logged.append,
)
)
assert response.status_code == 200
assert len(rt._client.calls) == 1
assert rt._client.calls[0][1]["model"] == "good-target"
assert any("is unhealthy, starting on" in line for line in logged)
row = get_table("gateway_usage_ledger").find_one(owner_id="preroute")
assert row["requested_model"] == "pre-bad"
assert row["model"] == "good-target"
finally:
routing.model_store.remove("pre-bad")
routing.model_store.remove("pre-good")
def test_chat_tries_original_when_chain_is_exhausted(local_db, monkeypatch):
from devplacepy.services.openai_gateway import health, routing
monkeypatch.setattr(gwmod.httpx, "AsyncClient", FakeClient_openai_gateway)
routing.model_store.set(
routing.ModelRouteIn(
source_model="exh-fb",
target_model="exh-fb-target",
fallback_model="exh-primary",
)
)
routing.model_store.set(
routing.ModelRouteIn(
source_model="exh-primary",
target_model="exh-primary-target",
fallback_model="exh-fb",
)
)
health.record_health(
"exh-primary", health.ProbeResult(False, "http_500", "boom", 1.0)
)
health.record_health(
"exh-fb", health.ProbeResult(False, "http_500", "boom", 1.0)
)
try:
svc = GatewayService()
cfg = svc.effective_config()
cfg["gateway_vision_enabled"] = False
rt = svc.runtime()
response = run_async(
rt.handle_chat(
{"model": "exh-primary", "messages": [{"role": "user", "content": "hi"}]},
cfg,
("guest", "exhausted"),
"test",
"default",
)
)
assert response.status_code == 200
assert [c[1]["model"] for c in rt._client.calls] == ["exh-primary-target"]
finally:
routing.model_store.remove("exh-primary")
routing.model_store.remove("exh-fb")
def test_models_endpoint_hides_unhealthy_routes(local_db):
from devplacepy.services.openai_gateway import health, routing
routing.model_store.set(
routing.ModelRouteIn(source_model="hide-me", target_model="v/hide")
)
health.record_health(
"hide-me", health.ProbeResult(False, "http_500", "boom", 1.0)
)
try:
svc = GatewayService()
payload = json.loads(svc._models_response().body.decode())
assert "hide-me" not in {m["id"] for m in payload["data"]}
health.record_health(
"hide-me", health.ProbeResult(True, "ok", "", 1.0)
)
payload = json.loads(svc._models_response().body.decode())
assert "hide-me" in {m["id"] for m in payload["data"]}
finally:
routing.model_store.remove("hide-me")
class FakeContextLengthClient_openai_gateway:
def __init__(self, *a, **k):
self.calls = []
@@ -2256,17 +2445,58 @@ def _resp_events_openai_gateway(model):
]
def _resp_tool_obj_openai_gateway(model):
obj = _resp_obj_openai_gateway(model)
obj["output"].append(
{
"type": "function_call",
"call_id": "call_7",
"name": "ext_bash",
"arguments": "{}",
}
)
return obj
def _resp_tool_events_openai_gateway(model):
return [
{"type": "response.created", "response": {"id": "resp_1"}},
{
"type": "response.output_item.added",
"output_index": 1,
"item": {
"type": "function_call",
"call_id": "call_7",
"name": "ext_bash",
"arguments": "",
},
},
{
"type": "response.function_call_arguments.delta",
"item_id": "call_7",
"output_index": 1,
"delta": "{}",
},
{
"type": "response.completed",
"response": _resp_tool_obj_openai_gateway(model),
},
]
class FakeResponsesClient_openai_gateway:
behavior = "ok"
def __init__(self, *a, **k):
self.calls = []
self.last_headers = {}
def build_request(self, method, url, headers=None, json=None, content=None):
return FakeRequest(method, url, json)
return FakeRequest(method, url, json, headers)
async def send(self, request, stream=False):
self.calls.append((request.url, request.json_body))
self.last_headers = dict(request.headers or {})
body = request.json_body or {}
if self.behavior == "error-envelope":
return FakeResp_openai_gateway(
@@ -2287,7 +2517,25 @@ class FakeResponsesClient_openai_gateway:
"error": {"message": "boom"},
}
)
if self.behavior == "attestation-denied":
return FakeResp_openai_gateway(
status=403,
payload={
"error": {
"message": "This API key is billed to a Muse Code "
"subscription. Muse Code subscriptions cover requests "
"from the Muse Code client only.",
"type": "permission_error",
"code": "client_attestation_denied",
}
},
)
model = body.get("model", "")
if self.behavior == "tool-call":
return FakeResponsesResp_openai_gateway(
payload=_resp_tool_obj_openai_gateway(model),
events=_resp_tool_events_openai_gateway(model),
)
return FakeResponsesResp_openai_gateway(
payload=_resp_obj_openai_gateway(model),
events=_resp_events_openai_gateway(model),
@@ -2374,6 +2622,141 @@ def test_responses_protocol_transpiles_request_and_response(local_db, monkeypatc
_teardown_responses_route_openai_gateway()
def test_muse_profile_headers_reach_the_wire(local_db, monkeypatch):
from devplacepy.services.openai_gateway import routing
monkeypatch.setattr(gwmod.httpx, "AsyncClient", FakeResponsesClient_openai_gateway)
FakeResponsesClient_openai_gateway.behavior = "ok"
routing.provider_store.set(
routing.ProviderIn(
name="wiremeta",
base_url="https://api.meta.ai/v1/responses",
api_key="sk-test",
protocol="responses",
client_profile="muse",
)
)
routing.model_store.set(
routing.ModelRouteIn(
source_model="wire-muse",
provider="wiremeta",
target_model="muse-spark",
kind="chat",
)
)
try:
svc = GatewayService()
cfg = svc.effective_config()
cfg["gateway_vision_enabled"] = False
rt = svc.runtime()
logged = []
resp = run_async(
rt.handle_chat(
{"model": "wire-muse", "messages": [{"role": "user", "content": "hi"}]},
cfg,
("guest", "test"),
"test",
"default",
log=logged.append,
)
)
assert resp.status_code == 200
sent_headers = rt._client.last_headers
assert sent_headers["X-Client-Id"] == "tbh:exec"
assert sent_headers["User-Agent"].startswith("muse-build/")
session = sent_headers["X-Tbh-Session-Id"]
assert session
assert sent_headers["X-Meta-Ai-Gateway-Session-Id"] == session
assert sent_headers["X-Tbh-Thread-Id"] == session
assert sent_headers["X-Tbh-Root-Session-Id"] == session
assert any("(client profile 'muse')" in line for line in logged)
finally:
routing.model_store.remove("wire-muse")
routing.provider_store.remove("wiremeta")
def _bash_tool_body_openai_gateway(**over):
body = _chat_body_openai_gateway(**over)
body["tools"] = [
{
"type": "function",
"function": {
"name": "bash",
"description": "run shell",
"parameters": {"type": "object", "properties": {}},
},
}
]
return body
def test_meta_tool_names_aliased_on_wire_and_restored(local_db, monkeypatch):
monkeypatch.setattr(gwmod.httpx, "AsyncClient", FakeResponsesClient_openai_gateway)
FakeResponsesClient_openai_gateway.behavior = "tool-call"
_setup_responses_route_openai_gateway()
try:
svc = GatewayService()
cfg = svc.effective_config()
cfg["gateway_vision_enabled"] = False
rt = svc.runtime()
logged = []
resp = run_async(
rt.handle_chat(
_bash_tool_body_openai_gateway(),
cfg,
("guest", "test"),
"test",
"default",
log=logged.append,
)
)
_, sent = rt._client.calls[-1]
assert sent["tools"][0]["name"] == "ext_bash"
assert any("bash->ext_bash" in line for line in logged)
assert resp.status_code == 200
payload = json.loads(bytes(resp.body).decode())
calls = payload["choices"][0]["message"]["tool_calls"]
assert calls[0]["function"]["name"] == "bash"
assert payload["choices"][0]["finish_reason"] == "tool_calls"
finally:
FakeResponsesClient_openai_gateway.behavior = "ok"
_teardown_responses_route_openai_gateway()
def test_meta_tool_names_restored_on_stream_chunks(local_db, monkeypatch):
monkeypatch.setattr(gwmod.httpx, "AsyncClient", FakeResponsesClient_openai_gateway)
FakeResponsesClient_openai_gateway.behavior = "tool-call"
_setup_responses_route_openai_gateway()
try:
svc = GatewayService()
cfg = svc.effective_config()
cfg["gateway_vision_enabled"] = False
rt = svc.runtime()
resp = run_async(
rt.handle_chat(
_bash_tool_body_openai_gateway(stream=True),
cfg,
("guest", "test"),
"test",
"default",
)
)
async def drain():
out = []
async for chunk in resp.body_iterator:
out.append(chunk if isinstance(chunk, str) else chunk.decode())
return "".join(out)
body = run_async(drain())
assert '"name": "bash"' in body
assert "ext_bash" not in body
assert "[DONE]" in body
finally:
FakeResponsesClient_openai_gateway.behavior = "ok"
_teardown_responses_route_openai_gateway()
def test_responses_protocol_stream_relays_chat_chunks(local_db, monkeypatch):
monkeypatch.setattr(gwmod.httpx, "AsyncClient", FakeResponsesClient_openai_gateway)
FakeResponsesClient_openai_gateway.behavior = "ok"
@@ -2440,6 +2823,13 @@ def test_responses_protocol_stream_relays_usage_when_asked(local_db, monkeypatch
body = run_async(drain())
assert '"usage"' in body
assert '"prompt_tokens": 5' in body
usage_chunks = [
json.loads(line[len("data:"):])
for line in body.splitlines()
if line.startswith("data: {") and '"usage"' in line
]
assert len(usage_chunks) == 1
assert usage_chunks[0]["choices"] == []
finally:
_teardown_responses_route_openai_gateway()
@@ -2467,6 +2857,84 @@ def test_responses_protocol_relays_error_envelope(local_db, monkeypatch):
_teardown_responses_route_openai_gateway()
def test_responses_protocol_attestation_denied_logs_guidance(
local_db, monkeypatch
):
monkeypatch.setattr(gwmod.httpx, "AsyncClient", FakeResponsesClient_openai_gateway)
FakeResponsesClient_openai_gateway.behavior = "attestation-denied"
_setup_responses_route_openai_gateway()
try:
svc = GatewayService()
cfg = svc.effective_config()
cfg["gateway_vision_enabled"] = False
rt = svc.runtime()
logged = []
resp = run_async(
rt.handle_chat(
_chat_body_openai_gateway(),
cfg,
("guest", "test"),
"test",
"default",
log=logged.append,
)
)
assert resp.status_code == 403
payload = json.loads(bytes(resp.body).decode())
assert payload["error"]["code"] == "client_attestation_denied"
assert any("pay-as-you-go" in line for line in logged)
finally:
FakeResponsesClient_openai_gateway.behavior = "ok"
_teardown_responses_route_openai_gateway()
def test_upstream_auth_guidance_covers_401_and_403():
denied = FakeResp_openai_gateway(
status=403,
payload={
"error": {
"message": "subscription only",
"type": "permission_error",
"code": "client_attestation_denied",
}
},
)
guidance = gwmod._upstream_auth_guidance(denied, denied.json())
assert "pay-as-you-go" in guidance
assert "aliasing" in guidance
assert "MUSE_RESERVED_TOOL_NAMES" in guidance
other_denied = FakeResp_openai_gateway(status=403, payload={"error": "nope"})
assert (
gwmod._upstream_auth_guidance(other_denied, other_denied.json()) is None
)
unauthed = FakeResp_openai_gateway(
status=401, payload={"error": {"message": "User not found.", "code": 401}}
)
guidance = gwmod._upstream_auth_guidance(unauthed, unauthed.json())
assert "api_key" in guidance
assert "User not found." in guidance
server_error = FakeResp_openai_gateway(status=500, payload={"error": "x"})
assert (
gwmod._upstream_auth_guidance(server_error, server_error.json()) is None
)
def test_should_fallback_model_unavailable_but_not_bad_request():
unavailable = FakeResp_openai_gateway(
status=400,
payload={"error": {"message": "Model is unavailable."}},
)
assert (
gwmod._should_fallback(unavailable, None, {"circuit_open": False}) is True
)
malformed = FakeResp_openai_gateway(
status=400, payload={"error": "bad schema"}
)
assert (
gwmod._should_fallback(malformed, None, {"circuit_open": False}) is False
)
def test_responses_protocol_failed_object_is_502(local_db, monkeypatch):
monkeypatch.setattr(gwmod.httpx, "AsyncClient", FakeResponsesClient_openai_gateway)
FakeResponsesClient_openai_gateway.behavior = "failed-object"
@@ -0,0 +1,240 @@
# retoor <retoor@molodetz.nl>
import httpx
from devplacepy.services.openai_gateway import health, routing
from tests.conftest import run_async
class _FakeProbeResponse:
def __init__(self, status_code, payload=None, text=""):
self.status_code = status_code
self._payload = payload
self.text = text
def json(self):
if isinstance(self._payload, Exception):
raise self._payload
return self._payload
class _FakeProbeClient:
instances = []
def __init__(self, response=None, error=None):
self.response = response
self.error = error
self.requested_url = None
self.sent_body = None
self.headers = None
_FakeProbeClient.instances.append(self)
async def __aenter__(self):
return self
async def __aexit__(self, *exc_info):
return False
async def post(self, url, json=None, headers=None):
self.requested_url = url
self.sent_body = json
if self.error is not None:
raise self.error
return self.response
def _patch_probe(monkeypatch, response=None, error=None):
def _factory(**kwargs):
client = _FakeProbeClient(response=response, error=error)
client.headers = kwargs.get("headers")
return client
monkeypatch.setattr("devplacepy.stealth.stealth_async_client", _factory)
def _probe_provider(name="healthprov", base_url=None, protocol="chat_completions"):
routing.provider_store.set(
routing.ProviderIn(
name=name,
base_url=base_url or "https://probe.example/v1/chat/completions",
api_key="k",
protocol=protocol,
)
)
def _probe_route(source, kind="chat", target="vendor/probe"):
routing.model_store.set(
routing.ModelRouteIn(
source_model=source,
provider="healthprov",
target_model=target,
kind=kind,
)
)
def _cleanup(names):
for source in names:
routing.model_store.remove(source)
routing.provider_store.remove("healthprov")
def test_probe_chat_ok(local_db, monkeypatch):
_probe_provider()
_probe_route("probe-chat")
_patch_probe(
monkeypatch,
_FakeProbeResponse(200, {"choices": [{"message": {"content": "OK"}}]}),
)
try:
result = run_async(health.probe_route("probe-chat"))
assert result.ok
assert result.code == "ok"
client = _FakeProbeClient.instances[-1]
assert client.requested_url.endswith("/chat/completions")
assert client.sent_body["model"] == "vendor/probe"
assert client.sent_body["stream"] is False
finally:
_cleanup(["probe-chat"])
def test_probe_chat_non_200_records_code(local_db, monkeypatch):
_probe_provider()
_probe_route("probe-chat-bad")
_patch_probe(
monkeypatch,
_FakeProbeResponse(
403,
{"error": {"message": "denied", "code": "client_attestation_denied"}},
'{"error": {"message": "denied", "code": "client_attestation_denied"}}',
),
)
try:
result = run_async(health.probe_route("probe-chat-bad"))
assert not result.ok
assert result.code == "client_attestation_denied"
assert "denied" in result.message
finally:
_cleanup(["probe-chat-bad"])
def test_probe_chat_timeout(local_db, monkeypatch):
_probe_provider()
_probe_route("probe-chat-slow")
_patch_probe(monkeypatch, error=httpx.TimeoutException("slow"))
try:
result = run_async(health.probe_route("probe-chat-slow"))
assert not result.ok
assert result.code == "timeout"
finally:
_cleanup(["probe-chat-slow"])
def test_probe_chat_responses_protocol_transpiles(local_db, monkeypatch):
_probe_provider(
base_url="https://probe.example/v1/responses", protocol="responses"
)
_probe_route("probe-resp")
_patch_probe(
monkeypatch,
_FakeProbeResponse(
200,
{
"object": "response",
"status": "completed",
"output": [
{
"type": "message",
"content": [{"type": "output_text", "text": "OK"}],
}
],
"usage": {"input_tokens": 1, "output_tokens": 1, "total_tokens": 2},
},
),
)
try:
result = run_async(health.probe_route("probe-resp"))
assert result.ok
client = _FakeProbeClient.instances[-1]
assert "input" in client.sent_body
assert client.sent_body["reasoning"] == {"effort": "minimal"}
finally:
_cleanup(["probe-resp"])
def test_probe_embed_and_image(local_db, monkeypatch):
_probe_provider()
_probe_route("probe-embed", kind="embed")
_patch_probe(
monkeypatch, _FakeProbeResponse(200, {"data": [{"embedding": [0.1]}]})
)
try:
result = run_async(health.probe_route("probe-embed"))
assert result.ok
client = _FakeProbeClient.instances[-1]
assert client.requested_url.endswith("/embeddings")
finally:
routing.model_store.remove("probe-embed")
_probe_route("probe-image", kind="image")
_patch_probe(
monkeypatch,
_FakeProbeResponse(200, {"data": [{"url": "https://img.example/h.png"}]}),
)
try:
result = run_async(health.probe_route("probe-image"))
assert result.ok
assert result.image_url == "https://img.example/h.png"
client = _FakeProbeClient.instances[-1]
assert client.sent_body["prompt"] == "a hedgehog and a bear"
finally:
_cleanup(["probe-image"])
def test_probe_unknown_route_returns_none(local_db):
assert run_async(health.probe_route("ghost-probe")) is None
def test_all_probes_every_route_one_by_one(local_db, monkeypatch):
_probe_provider()
_probe_route("probe-all-a")
_probe_route("probe-all-b")
seen = []
async def fake_probe(source):
seen.append(source)
ok = source != "probe-all-b"
return health.ProbeResult(ok, "" if ok else "http_500", "" if ok else "x", 1.0)
monkeypatch.setattr(health, "probe_route", fake_probe)
try:
tested, failed = run_async(health.test_all())
assert "probe-all-a" in seen and "probe-all-b" in seen
assert tested >= 2 and failed >= 1
assert routing.model_store.get("probe-all-a").health_status == "ok"
assert routing.model_store.get("probe-all-b").health_status == "bad"
finally:
_cleanup(["probe-all-a", "probe-all-b"])
def test_record_health_writes_and_clears(local_db):
_probe_provider()
_probe_route("probe-record")
try:
assert health.record_health(
"probe-record", health.ProbeResult(False, "http_500", "boom", 3.0)
)
route = routing.model_store.get("probe-record")
assert route.health_status == "bad"
assert route.health_code == "http_500"
assert route.health_message == "boom"
assert route.health_checked_at
assert health.record_health(
"probe-record", health.ProbeResult(True, "ok", "", 1.0)
)
route = routing.model_store.get("probe-record")
assert route.health_status == "ok"
assert route.health_code == ""
assert not health.record_health("ghost-record", health.ProbeResult(True, "ok", "", 1.0))
finally:
_cleanup(["probe-record"])
@@ -0,0 +1,153 @@
# retoor <retoor@molodetz.nl>
from devplacepy.services.openai_gateway import muse_code
def test_headers_include_the_expected_client_identity_fields():
headers = muse_code.muse_impersonation_headers()
assert set(headers) == {
"User-Agent",
"X-Client-Id",
"X-Tbh-Session-Id",
"X-Meta-Ai-Gateway-Session-Id",
"X-Tbh-Thread-Id",
"X-Tbh-Root-Session-Id",
"X-Tbh-Agent-Role",
"X-Tbh-Contributor-Mode",
}
assert headers["User-Agent"].startswith("muse-build/")
assert "(non-interactive;" in headers["User-Agent"]
assert headers["X-Client-Id"] == "tbh:exec"
assert headers["X-Tbh-Agent-Role"] == "main"
def test_reserved_tool_names_cover_the_measured_denylist():
assert muse_code.MUSE_RESERVED_TOOL_NAMES == frozenset(
{
"workflow",
"read_file",
"search",
"write_file",
"edit_file",
"read_memory",
"add_memory",
"edit_memory",
"web_search",
"bash",
"bash_input",
"cron_create",
"cron_delete",
"cron_list",
"get_goal",
"create_goal",
"update_goal",
"report_progress",
"read_skill",
"write_todos",
}
)
def _func_tool(name):
return {"type": "function", "function": {"name": name, "arguments": "{}"}}
def test_tool_aliases_cover_declared_and_history_names():
payload = {
"tools": [_func_tool("bash"), _func_tool("innocent")],
"messages": [
{
"role": "assistant",
"tool_calls": [_func_tool("read_file")],
}
],
}
aliases = muse_code.tool_aliases_for(payload)
assert aliases == {"ext_bash": "bash", "ext_read_file": "read_file"}
def test_tool_aliases_grow_past_collisions():
payload = {"tools": [_func_tool("bash"), _func_tool("ext_bash")]}
aliases = muse_code.tool_aliases_for(payload)
assert aliases == {"ext_ext_bash": "bash"}
def test_tool_aliases_empty_when_clean():
assert muse_code.tool_aliases_for({"tools": [_func_tool("innocent")]}) == {}
assert muse_code.tool_aliases_for({}) == {}
def test_alias_chat_tools_rewrites_every_name_shape():
payload = {
"tools": [_func_tool("bash")],
"tool_choice": {"type": "function", "function": {"name": "bash"}},
"messages": [
{
"role": "assistant",
"tool_calls": [_func_tool("bash")],
}
],
}
renamed = muse_code.alias_chat_tools(
payload, muse_code.tool_aliases_for(payload)
)
assert renamed is not payload
assert renamed["tools"][0]["function"]["name"] == "ext_bash"
assert renamed["tool_choice"]["function"]["name"] == "ext_bash"
assert (
renamed["messages"][0]["tool_calls"][0]["function"]["name"]
== "ext_bash"
)
assert payload["tools"][0]["function"]["name"] == "bash"
def test_alias_chat_tools_rewrites_allowed_tools_entries():
payload = {
"tool_choice": {
"type": "allowed_tools",
"mode": "auto",
"tools": [_func_tool("bash"), _func_tool("innocent")],
}
}
renamed = muse_code.alias_chat_tools(payload, {"ext_bash": "bash"})
entries = renamed["tool_choice"]["tools"]
assert entries[0]["function"]["name"] == "ext_bash"
assert entries[1]["function"]["name"] == "innocent"
def test_alias_chat_tools_passthrough_when_clean():
payload = {"tools": [_func_tool("innocent")]}
assert muse_code.alias_chat_tools(payload, {}) is payload
def test_restore_completion_and_chunk_names():
aliases = {"ext_bash": "bash"}
comp = {
"choices": [
{"message": {"tool_calls": [_func_tool("ext_bash"), _func_tool("x")]}},
]
}
muse_code.restore_completion_names(comp, aliases)
names = [c["function"]["name"] for c in comp["choices"][0]["message"]["tool_calls"]]
assert names == ["bash", "x"]
chunk = {"choices": [{"delta": {"tool_calls": [_func_tool("ext_bash")]}}]}
muse_code.restore_chunk_names(chunk, aliases)
assert chunk["choices"][0]["delta"]["tool_calls"][0]["function"]["name"] == "bash"
assert muse_code.restore_completion_names(comp, {}) is comp
assert muse_code.restore_chunk_names(chunk, {}) is chunk
def test_session_id_is_stable_and_shared_across_calls():
first = muse_code.muse_impersonation_headers()
second = muse_code.muse_impersonation_headers()
session_keys = (
"X-Tbh-Session-Id",
"X-Meta-Ai-Gateway-Session-Id",
"X-Tbh-Thread-Id",
"X-Tbh-Root-Session-Id",
)
shared = first["X-Tbh-Session-Id"]
assert len(shared) == 36 and shared.count("-") == 4
for key in session_keys:
assert first[key] == shared
assert second[key] == shared
@@ -385,6 +385,25 @@ def test_response_object_to_chat_completion():
}
def test_response_object_usage_details_pass_through():
comp, _ = responses_object_to_chat_completion(
{
"id": "r",
"output": [],
"usage": {
"input_tokens": 10,
"output_tokens": 4,
"total_tokens": 14,
"input_tokens_details": {"cached_tokens": 6},
"output_tokens_details": {"reasoning_tokens": 2},
},
}
)
assert comp["usage"]["prompt_tokens"] == 10
assert comp["usage"]["prompt_tokens_details"] == {"cached_tokens": 6}
assert comp["usage"]["completion_tokens_details"] == {"reasoning_tokens": 2}
def test_response_object_finish_reasons():
comp, _ = responses_object_to_chat_completion(
{
@@ -451,6 +470,9 @@ def test_responses_failure_and_error_shapes():
assert responses_error_object({"error": {"message": "m", "code": "c"}}) == {
"error": {"message": "m", "code": "c"}
}
assert responses_error_object(
{"error": {"message": "m", "type": "t", "code": "c", "param": "p"}}
) == {"error": {"message": "m", "type": "t", "code": "c", "param": "p"}}
assert responses_error_object({"a": 1}) is None
@@ -475,7 +497,9 @@ def test_stream_responses_to_chat_text_and_done():
}
)
assert done[0]["choices"][0]["finish_reason"] == "stop"
assert done[0]["usage"]["prompt_tokens"] == 1
assert "usage" not in done[0]
assert done[1]["choices"] == []
assert done[1]["usage"]["prompt_tokens"] == 1
def test_stream_responses_to_chat_tool_calls():
@@ -179,6 +179,87 @@ def test_resolve_fallback_ignores_a_fallback_of_a_different_kind(local_db):
_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(
@@ -362,6 +443,31 @@ def test_provider_without_a_client_profile_gets_no_extra_headers(local_db):
_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")
@@ -7,6 +7,7 @@ from devplacepy.services.openai_gateway.usage import (
USAGE_FIELDS,
Pricing,
accumulate_usage,
classify_error,
compute_cost,
new_usage_totals,
normalize_usage,
@@ -325,3 +326,13 @@ def test_upstream_reported_model_get_raising_never_propagates():
raise RuntimeError("boom too")
assert upstream_reported_model(HostileHeaders()) is None
def test_classify_error_model_unavailable_400_is_model_not_found():
body = '{"error":{"type":"server_error","message":"Upstream request failed: Model is unavailable."}}'
assert classify_error(400, None, body) == "model_not_found"
assert classify_error(404, None, "") == "model_not_found"
assert classify_error(400, None, '{"error":"bad schema"}') == "bad_request"
assert (
classify_error(400, None, "context window exceeded") == "context_length"
)
+2 -2
View File
@@ -134,7 +134,7 @@ def test_grade_free_text_uses_a_valid_verdict(monkeypatch):
def test_grade_free_text_passes_the_answering_key_through(monkeypatch):
seen = {}
def capture(api_key, system, text, timeout, model=None, bypass_preamble=False):
def capture(api_key, system, text, timeout, model=None, bypass_preamble=False, app_reference=None):
seen["api_key"] = api_key
seen["bypass_preamble"] = bypass_preamble
return json.dumps({"score": 1.0}), None
@@ -147,7 +147,7 @@ def test_grade_free_text_passes_the_answering_key_through(monkeypatch):
def test_grade_free_text_bypasses_the_operator_preamble(monkeypatch):
seen = {}
def capture(api_key, system, text, timeout, model=None, bypass_preamble=False):
def capture(api_key, system, text, timeout, model=None, bypass_preamble=False, app_reference=None):
seen["bypass_preamble"] = bypass_preamble
return json.dumps({"score": 1.0}), None