@miller-tech/uap 1.96.6 → 1.98.0

package/tools/agents/config/json-response.gbnf

@@ -0,0 +1,7 @@
+root   ::= object | array
+value  ::= object | array | string | number | ("true" | "false" | "null") ws
+object ::= "{" ws ( string ":" ws value ("," ws string ":" ws value)* )? "}" ws
+array  ::= "[" ws ( value ("," ws value)* )? "]" ws
+string ::= "\"" ( [^"\\\x7F\x00-\x1F] | "\\" (["\\bfnrt] | "u" [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F]) )* "\"" ws
+number ::= ("-"? ([0-9] | [1-9] [0-9]*)) ("." [0-9]+)? ([eE] [-+]? [0-9]+)? ws
+ws     ::= [ \t\n]*

package/tools/agents/scripts/anthropic_proxy.py

@@ -829,6 +829,55 @@ def _load_thinking_grammar(path: str) -> str:
 
 THINKING_GBNF = _load_thinking_grammar(PROXY_THINKING_GRAMMAR_PATH)
 
+# JSON-response grammar (evaluator verdicts): when a client marks a no-tool
+# request with the x-uap-json-response header, constrain sampling to a bare
+# JSON value. Kills the "<think> ate the verdict / unparseable judgment"
+# failure class at the decoder. Default on; PROXY_JSON_RESPONSE_GRAMMAR=off.
+PROXY_JSON_RESPONSE_GRAMMAR = os.environ.get(
+    "PROXY_JSON_RESPONSE_GRAMMAR", "on"
+).lower() not in {"0", "false", "off", "no"}
+PROXY_JSON_RESPONSE_GRAMMAR_PATH = os.path.abspath(
+    os.environ.get(
+        "PROXY_JSON_RESPONSE_GRAMMAR_PATH",
+        os.path.join(os.path.dirname(__file__), "..", "config", "json-response.gbnf"),
+    )
+)
+
+
+def _load_json_response_grammar(path: str) -> str:
+    if not PROXY_JSON_RESPONSE_GRAMMAR:
+        return ""
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            return fh.read().strip()
+    except OSError as exc:
+        logger.warning("JSON-response grammar disabled: failed to read %s (%s)", path, exc)
+        return ""
+
+
+JSON_RESPONSE_GBNF = _load_json_response_grammar(PROXY_JSON_RESPONSE_GRAMMAR_PATH)
+
+
+def _apply_json_response_grammar(openai_body: dict, anthropic_body: dict) -> None:
+    """Constrain a marked no-tool request to emit a bare JSON value.
+
+    Fires only when the client tagged the request (x-uap-json-response, staged
+    into the body as _uap_json_response), there are no tools, the grammar
+    loaded, and nothing upstream set a grammar already. Thinking is forced off
+    — the grammar forbids a <think> preamble by construction.
+    """
+    if not anthropic_body.get("_uap_json_response"):
+        return
+    if not JSON_RESPONSE_GBNF:
+        return
+    if openai_body.get("tools") or openai_body.get("grammar"):
+        return
+    openai_body["grammar"] = JSON_RESPONSE_GBNF
+    openai_body["enable_thinking"] = False
+    ctk = openai_body.setdefault("chat_template_kwargs", {})
+    ctk["enable_thinking"] = False
+    logger.info("JSON-RESPONSE grammar applied (evaluator verdict turn)")
+
 
 def _apply_thinking_grammar(request_body: dict) -> None:
     """Apply the structured-thinking GBNF grammar to non-tool turns.
@@ -4799,6 +4848,8 @@ def build_openai_request(
 
     _apply_thinking_grammar(openai_body)
 
+    _apply_json_response_grammar(openai_body, anthropic_body)
+
     # qwen3.5-enhanced.jinja (the MTP/130 config template) rejects an assistant
     # PREFILL (trailing assistant message) unless thinking is disabled VIA
     # chat_template_kwargs — the top-level `enable_thinking` flag is not read by
@@ -8803,6 +8854,11 @@ async def messages(request: Request):
     model = body.get("model", "default")
     client_id = resolve_client_id(request)
 
+    # Evaluator-verdict marker: clients tag JSON-only completions via header;
+    # stage it into the body so build_openai_request can grammar-constrain it.
+    if request.headers.get("x-uap-json-response"):
+        body["_uap_json_response"] = True
+
     # Periodically re-detect context window from upstream (handles server restarts)
     await _maybe_recheck_context_window()