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
+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"