# retoor 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")]