A developer calls a reasoning model through OpenAI's Responses API with `max_output_tokens` set, and gets back a response whose `output_text` is empty even though the usage data shows a large number of billed output tokens. According to OpenAI's documentation, what is most likely happening, and how should the application detect it?
- the response's `status` field will be `error` with an `error.type` of `server_error`, indicating an internal fault on OpenAI's infrastructure that is unrelated to the token limit set on the request
- this cannot happen when `max_output_tokens` is set, since OpenAI's documentation guarantees a visible answer is always produced in full before any internal reasoning tokens are counted against the limit
- the response's `output` array will always still contain a text message item in this situation, so an application never needs to check anything beyond `output_text` before using the result
- the response's `status` field will be `incomplete`, with `incomplete_details.reason` set to `max_output_tokens`, because a reasoning model's internal reasoning tokens can consume the entire token budget before any visible answer is produced; an application should check `status` and `incomplete_details` rather than assuming `output_text` is populated, and should reserve enough budget for both reasoning and the visible answer
Why D? And why not the others?
Correct answer: D. the response's `status` field will be `incomplete`, with `incomplete_details.reason` set to `max_output_tokens`, because a reasoning model's internal reasoning tokens can consume the entire token budget before any visible answer is produced; an application should check `status` and `incomplete_details` rather than assuming `output_text` is populated, and should reserve enough budget for both reasoning and the visible answer
OpenAI's documentation on reasoning models describes exactly this failure mode: because a reasoning model generates internal reasoning tokens in addition to the visible answer, and both draw from the same `max_output_tokens` budget, the model can exhaust the entire budget on reasoning before producing any visible text, leaving `output_text` empty despite non-zero billed usage; the documented signal for this is a response `status` of `incomplete` together with `incomplete_details.reason` equal to `max_output_tokens`, and the fix is reserving a larger token budget. Describing this as a `server_error` is wrong because nothing about the infrastructure has failed -- the request completed, just without reaching a visible answer, which is a documented, expected outcome rather than a fault. The option claiming this can never happen contradicts the documented behavior directly, since the guarantee it describes does not exist. The option asserting a text item is always present is wrong because the whole documented failure mode is that no message item, and therefore no `output_text`, may be emitted when reasoning consumes the full budget.
Source: OpenAI, Reasoning models guide, https://developers.openai.com/api/docs/guides/reasoning