forked from retoor/devplacepy
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>
175 lines
6.6 KiB
Python
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")]
|