Model-dependent reasoning

Reasoning Models

Reasoning-capable models may use additional internal computation before producing the final answer.

Some models are designed to “think through” problems step-by-step. DEVUP AI does not guarantee exposure of a model's private chain-of-thought. Available controls and returned metadata depend on the selected model.

How it works

Step 1

User request

Step 2

Reasoning-capable model

Step 3

Internal processing

Step 4

Final answer

Step 5

Usage metadata, when returned

Using reasoning models

You can interact with reasoning models using standard Chat Completions.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Pro",
    messages=[{"role": "user", "content": "Solve this step by step: 15! / 13!"}]
)

message = response.choices[0].message
print(message.content)

if getattr(message, "reasoning_content", None):
    print(message.reasoning_content)

Reasoning controls

GET /v1/models shows how each model reasons, and so does GET /v1/models/{model} for one model. supports.reasoning is true for a model that reasons. The reasoning object gives the model's reasoning mode and, when known, the request parameter that controls it with the reasoning levels you can send to the model. supports.reasoning: true with no reasoningobject means the model's reasoning mode is not known yet.

mode: "always" (the model reasons without being asked), "on_request" (it reasons when asked) or "none" (no configurable reasoning mode; a reasoning parameter is answered with the notice reasoning_not_available).
parameter: the request parameter that turns reasoning on or sets its level, for example reasoning_effort. It can appear with mode "always", where it sets the level, and with "on_request".
values: the reasoning levels you can send to this model with parameter, from least to most reasoning. none, when listed, turns reasoning off. How much each level changes the reasoning depends on the model. Some models list a single value, which turns reasoning on. For reasoning_effort, the values come from none, minimal, low, medium, high, xhigh and max, in that order.

json

{
  "supports": {
    "reasoning": true,
    "reasoning_can_be_disabled": true
  },
  "reasoning": {
    "mode": "on_request",
    "parameter": "reasoning_effort",
    "values": ["none", "low", "medium", "high"]
  }
}

Illustrative excerpt of a model object; supports is abridged.

To set the level, send one of the listed values as reasoning_effort in a POST /v1/chat/completions request, for example "reasoning_effort": "high".

Reasoning output

Reasoning-capable models may return their chain of thought in a separate reasoning_content field on the message object, alongside the standard content field. Depending on the model, this field may be null or absent entirely. Clients must not assume that reasoning_content is present.

The reasoning is returned in reasoning_content — message.reasoning_content without streaming, delta.reasoning_content when streaming — and content holds only the answer. When a model returns its thinking inside content, wrapped in <think> and </think>, it is moved to reasoning_content, with or without streaming. The same applies to models that use <thinking>, and to models that start their reply already inside the thinking block and only close it with </think>. Text that only mentions these tags is left unchanged. When such a reply is cut off by max_tokens while the model is still reasoning, the reasoning is returned in reasoning_content and content is empty. If the thinking block is never closed and the response was not cut short by max_tokens, content is returned exactly as the model produced it, so the answer is never lost.

Token budget

Reasoning tokens are counted as completion tokens and are billed. Some models report them separately in usage.completion_tokens_details.reasoning_tokens; others, such as moonshotai/Kimi-K3, report 0 there even when they reason, and their reasoning is included in completion_tokens only. Any configured max_tokens budget must cover reasoning and the answer. If the budget is exhausted during reasoning, the response carries finish_reason "length" with an empty content string — and is still billed. With images, audio or video in the request, allow more — 2000 or more is a safe start.

Handling empty content

When processing responses from reasoning models, check the returned finish_reason and handle cases where content === "" rather than assuming a non-empty string is always returned.

Model-specific extensions

Transparent payload forwarding

DEVUP AI guarantees standard OpenAI-compatible Chat Completions fields. Additional, model-specific fields in the request body are accepted and passed to the model where supported.

This means you may pass optional, model-specific configuration fields (such as reasoning_effort or reasoning objects) in your payload. If the selected model supports them, they will be processed. They are not portable across all models, and their behavior is not guaranteed by the DEVUP AI contract.

When to use reasoning models

Reasoning-capable models excel at tasks requiring careful deduction, but they are not universally superior.

Multi-step analysis

Mathematics and logic

Code planning and debugging

Complex decision support

Constraint-heavy tasks

Tasks that may not benefit from reasoning

Simple extraction, classification, translation, and short factual queries may not benefit from additional reasoning effort and could introduce unnecessary latency.

Usage and limitations

Latency

Reasoning depth may affect latency, output usage, and cost depending on the selected model. Internal processing before returning the first visible token can take significant time.

Model-dependent Support

Check supports.reasoning and the reasoning object of each model in GET /v1/models, or the model catalog, to identify which models reason and the reasoning levels you can send to each (see Reasoning controls).

Output Limits & Metadata

Reasoning models may consume output tokens for their internal processing. Any reported usage metadata (e.g. reasoning token counts) or streaming reasoning traces depend on the selected model and are not guaranteed.