Files
devplacepy/tests/unit/services/openai_gateway/shape.py
T
retoorandClaude Sonnet 5.5 151476125f Gateway: auto-resolve request shape per provider and model
An upstream that rejects a key the gateway adds (e.g. thinking) now gets
retried with other shapes on a parsable 400/422; the working method is
stored per (provider, target model) and applied first-try from then on.
Fallback attempts are re-shaped per attempt. Admin list/reset, Devii
tools, audit event and ledger resolved_method included.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-13 11:34:26 +01:00

175 lines
6.6 KiB
Python

# retoor <retoor@molodetz.nl>
import json
from devplacepy.services.openai_gateway.shape import (
MAX_RESOLVE_ATTEMPTS,
NATIVE_METHOD,
RejectedKeys,
ShapeMethod,
ShapeResolver,
ShapeRetrier,
)
VAIDS_BODY = json.dumps(
{
"details": {"_errors": ["Unrecognized key(s) in object: 'thinking'"]},
"error": "Invalid request parameters",
"issues": [
{
"code": "unrecognized_keys",
"keys": ["thinking"],
"path": [],
"message": "Unrecognized key(s) in object: 'thinking'",
}
],
}
)
class MemoryStore_openai_gateway:
def __init__(self):
self.rows = {}
self.forgotten = []
def get(self, provider, model):
return self.rows.get((provider, model))
def remember(self, provider, model, method):
self.rows[(provider, model)] = method
def forget(self, provider, model):
self.forgotten.append((provider, model))
return self.rows.pop((provider, model), None) is not None
def test_parse_real_vaids_body():
assert RejectedKeys.parse(VAIDS_BODY) == ("thinking",)
def test_parse_openai_style_bodies():
assert RejectedKeys.parse(
'{"error":{"message":"Unrecognized request argument supplied: foo","param":null}}'
) == ("foo",)
assert RejectedKeys.parse(
'{"error":{"message":"Unknown parameter: \'stream_options\'.",'
'"param":"stream_options","code":"unknown_parameter"}}'
) == ("stream_options",)
def test_parse_serde_style_and_plain_text():
assert RejectedKeys.parse("unknown field `thinking`, expected one of `model`") == (
"thinking",
)
def test_parse_returns_empty_for_a_genuine_bad_request():
assert RejectedKeys.parse('{"error":{"message":"invalid request: bad param"}}') == ()
assert RejectedKeys.parse("") == ()
assert RejectedKeys.parse(None) == ()
def test_resolver_prefers_none_when_thinking_is_rejected():
resolver = ShapeResolver("deepseek", "chat_completions")
method = resolver.next_method({NATIVE_METHOD}, NATIVE_METHOD, ("thinking",))
assert method == ShapeMethod("none")
def test_resolver_skips_dialects_that_emit_the_rejected_key():
resolver = ShapeResolver("deepseek", "chat_completions")
tried = {NATIVE_METHOD, ShapeMethod("none")}
method = resolver.next_method(tried, ShapeMethod("none"), ("reasoning",))
assert method == ShapeMethod("deepseek")
def test_resolver_adds_a_droppable_key():
resolver = ShapeResolver("deepseek", "chat_completions")
method = resolver.next_method({NATIVE_METHOD}, NATIVE_METHOD, ("stream_options",))
assert method == ShapeMethod("native", ("stream_options",))
def test_resolver_refuses_unknown_and_protected_keys():
resolver = ShapeResolver("deepseek", "chat_completions")
for key in ("messages", "model", "tools", "something_else"):
assert resolver.next_method({NATIVE_METHOD}, NATIVE_METHOD, (key,)) is None
def test_resolver_responses_ladder_is_reasoning_only():
resolver = ShapeResolver("deepseek", "responses")
method = resolver.next_method({NATIVE_METHOD}, NATIVE_METHOD, ("reasoning",))
assert method == ShapeMethod("none")
assert resolver.next_method({NATIVE_METHOD}, NATIVE_METHOD, ("thinking",)) is None
def test_method_json_round_trip_and_validation():
method = ShapeMethod("none", ("stream_options",))
assert ShapeMethod.from_json(method.to_json()) == method
assert ShapeMethod.from_json('{"thinking_dialect":"bogus","drop_keys":[]}') is None
assert ShapeMethod.from_json('{"thinking_dialect":"none","drop_keys":["tools"]}') is None
assert ShapeMethod.from_json("not json") is None
def test_apply_none_clears_thinking_and_native_writes_the_dialect():
cfg = {"gateway_upstream_url": "https://strict.example/v1/chat/completions"}
payload = {"model": "m", "messages": [], "thinking": {"type": "enabled"}}
native = NATIVE_METHOD.apply(payload, cfg, "chat_completions", False, lambda m: None)
assert native["thinking"] == {"type": "enabled"}
none = ShapeMethod("none").apply(payload, cfg, "chat_completions", False, lambda m: None)
assert "thinking" not in none and "reasoning" not in none
assert payload["thinking"] == {"type": "enabled"}
def test_apply_drops_stream_options_when_learned():
cfg = {"gateway_upstream_url": "https://strict.example/v1/chat/completions"}
payload = {"model": "m", "messages": [], "stream": True}
kept = NATIVE_METHOD.apply(payload, cfg, "chat_completions", True, lambda m: None)
assert kept["stream_options"] == {"include_usage": True}
dropped = ShapeMethod("native", ("stream_options",)).apply(
payload, cfg, "chat_completions", True, lambda m: None
)
assert "stream_options" not in dropped
def test_strip_wire_removes_reasoning_for_responses_none():
body = {"model": "m", "reasoning": {"effort": "minimal"}, "input": []}
stripped = ShapeMethod("none").strip_wire(body, "responses")
assert "reasoning" not in stripped and body["reasoning"]
assert NATIVE_METHOD.strip_wire(body, "responses") is body
def test_retrier_success_remembers_and_native_success_does_not():
store = MemoryStore_openai_gateway()
retrier = ShapeRetrier.for_route(store, "p", "m", "chat_completions", "deepseek", lambda m: None)
retrier.succeeded()
assert store.rows == {}
method = retrier.next_after(400, VAIDS_BODY)
assert method == ShapeMethod("none")
retrier.succeeded()
assert store.rows[("p", "m")] == ShapeMethod("none")
def test_retrier_ignores_non_shape_statuses_and_unparsable_bodies():
store = MemoryStore_openai_gateway()
retrier = ShapeRetrier.for_route(store, "p", "m", "chat_completions", "deepseek", lambda m: None)
assert retrier.next_after(500, VAIDS_BODY) is None
assert retrier.next_after(400, '{"error":"nope"}') is None
def test_retrier_attempts_are_capped():
store = MemoryStore_openai_gateway()
retrier = ShapeRetrier.for_route(store, "p", "m", "chat_completions", "deepseek", lambda m: None)
retrier.attempts = MAX_RESOLVE_ATTEMPTS
assert retrier.next_after(400, VAIDS_BODY) is None
def test_retrier_forgets_a_rejected_learned_method_once():
store = MemoryStore_openai_gateway()
store.rows[("p", "m")] = ShapeMethod("openrouter")
retrier = ShapeRetrier.for_route(store, "p", "m", "chat_completions", "deepseek", lambda m: None)
assert retrier.method == ShapeMethod("openrouter")
method = retrier.next_after(
400, '{"issues":[{"code":"unrecognized_keys","keys":["reasoning"]}]}'
)
assert method == NATIVE_METHOD
assert store.forgotten == [("p", "m")]