Reasoning

Control how much a model thinks with the same options on every provider.

Choose a reasoning model

Models that reason list reasoning in supported_parameters. The catalog's reasoning object shows the efforts the model serves (supported_efforts, highest first), its default (default_effort, default_enabled) and whether reasoning can be switched off (mandatory).

Set the effort

reasoning.effort, or its shorthand reasoning_effort, accepts none, minimal, low, medium, high, xhigh and max. Curated routes map these choices to their native controls. If a route does not offer a requested level, the gateway uses the nearest offered level; a tie rounds up. Routes that offer the effort exactly are tried first. provider.require_parameters: true does not turn discrete levels into exact token budgets or require an exact match for every nonzero effort. Without a reasoning choice, the curated model default applies. GET /v1/generation reports the mapped effort as reasoning_effort where available.

Budget or hard limit?

On routes with a curated effort mapping, reasoning.max_tokens is an approximate effort selector, not a hard reasoning-token limit. The selector compares the budget with shares of the effective total-output limit: xhigh 95 %, high 80 %, medium 50 %, low 20 %, minimal 10 %. It selects the highest share that fits, then maps to the nearest offered level. Even a small positive budget can select the lowest nonzero level. With both valid max_tokens and max_completion_tokens, the smaller limit is used; otherwise the route's declared output limit is used. Without either, selection uses the nonzero default or the lowest level. A budget of zero without an effort requests off.

For example, with a total-output limit of 1000 and a budget of 800, a route offering only low and high selects high. This does not promise at most 800 reasoning tokens or reserve 200 tokens for visible text. A non-null effort takes precedence over the budget.

Legacy numeric mappings may forward a budget rather than select an effort. Forwarding alone is not evidence that the provider enforces a hard reasoning-token cap. Numeric forwarding requires a declared route output or context bound; a larger numeric budget is rejected. These admission bounds are not an additional reasoning allowance. Use the route's documented contract rather than inferring a guarantee from an accepted request.

curl

curl --request POST \
  --url 'https://api.tokenlane.de/v1/chat/completions' \
  --header 'Authorization: Bearer YOUR_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
  "model": "deepseek/deepseek-v4-flash-0731",
  "messages": [
    {
      "role": "user",
      "content": "Hello"
    }
  ],
  "max_tokens": 400,
  "reasoning": {
    "effort": "low"
  },
  "provider": {
    "require_parameters": true
  }
}'

node

import OpenAI from 'openai';

const client = new OpenAI({ baseURL: "https://api.tokenlane.de/v1", apiKey: process.env.TOKENLANE_API_KEY });
const response = await client.chat.completions.create({
  "model": "deepseek/deepseek-v4-flash-0731",
  "messages": [
    {
      "role": "user",
      "content": "Hello"
    }
  ],
  "max_tokens": 400,
  "reasoning": {
    "effort": "low"
  },
  "provider": {
    "require_parameters": true
  }
}, {});
console.log(response);

python

import os
import json
from openai import OpenAI

client = OpenAI(base_url="https://api.tokenlane.de/v1", api_key=os.environ["TOKENLANE_API_KEY"])
body = json.loads(r'''{
  "model": "deepseek/deepseek-v4-flash-0731",
  "messages": [
    {
      "role": "user",
      "content": "Hello"
    }
  ],
  "max_tokens": 400,
  "reasoning": {
    "effort": "low"
  },
  "provider": {
    "require_parameters": true
  }
}''')
response = client.chat.completions.create(
    model=body["model"],
    messages=body["messages"],
    max_tokens=body["max_tokens"],
    extra_body=json.loads(r'''{
  "reasoning": {
    "effort": "low"
  },
  "provider": {
    "require_parameters": true
  }
}''')
)
print(response)

vercel

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
import { generateText } from 'ai';

const tokenlane = createOpenAICompatible({ name: 'tokenlane', baseURL: "https://api.tokenlane.de/v1", apiKey: process.env.TOKENLANE_API_KEY, includeUsage: true });
const result = await generateText({
  model: tokenlane("deepseek/deepseek-v4-flash-0731"),
  messages: [
  {
    "role": "user",
    "content": "Hello"
  }
],
  maxOutputTokens: 400,
  providerOptions: { tokenlane: {
  "reasoning": {
    "effort": "low"
  },
  "provider": {
    "require_parameters": true
  }
} },
});
console.log(result.text);

Switch reasoning off

reasoning.effort: "none" or reasoning.enabled: false requests that reasoning computation stop. To require this rather than accept a best effort, also set provider.require_parameters: true:

{
  "reasoning": { "enabled": false },
  "provider": { "require_parameters": true }
}

The gateway then excludes routes without a curated off mapping, or whose effective adapter parameters do not preserve it, before calling a provider. A different suitable route may be used, but organization, workspace, key, data-protection and price restrictions still apply. If no route fits, the response is 404 no_endpoint without an upstream call. The catalog's model-level efforts combine routes; they do not prove that a pinned provider can switch off. Plain forwarding of enabled: false is not an off guarantee.

Without strict parameter requirements, existing best-effort behavior remains: mandatory-reasoning routes use their lowest level and hide reasoning from the response. x-ignored-params names the unfulfilled off control. Hidden reasoning can still be computed and billed, including when reasoning_tokens is missing. This is not equivalent to a strict off request.

To hide reasoning while allowing computation, use reasoning.exclude: true (or the legacy include_reasoning: false). This is a response-only setting, also with strict parameter requirements. It does not prevent reasoning costs. Confirmed usage and accounting are not reduced merely because reasoning is hidden.

Contradictory options (enabled: false with a non-none effort, enabled: true with none, or different effort aliases) are rejected with 400 and the field path.

Efforts per model

ModelEfforts servedDefaultCan be switched off
deepseek/deepseek-v4-pro-0813max, xhigh (Lyceum), high, medium, lowlowyes, on Lyceum; TensorX always reasons
deepseek/deepseek-v4.1-flash-1017max, high, medium (Lyceum), lowlowyes, on Lyceum; TensorX always reasons
minimax/minimax-m3on or off onlyonyes
mistralai/mistral-large-4-0off only for nowoffalways off
moonshotai/kimi-k2.7-codealways on, no levelsonno
openai/gpt-oss-120bhigh, medium, lowlowno
qwen/qwen3.5-397b-a17b, qwen/qwen3.5-9bon or off onlyoffyes
qwen/qwen3.8-27b, qwen/qwen3.8-flash-nextxhigh, medium, lowlowyes
z-ai/glm-5.3, z-ai/glm-5.3-flashmax (Grunden), high, lowlowno

Read only what is returned

Providers can return reasoning separately from the final answer, omit it, or report only its tokens. reasoning.exclude removes reasoning from the response; it does not stop computation or billing. Visible reasoning is not a complete account of the model's internal process.

Avoid answers without content

Reasoning counts towards max_tokens. If it uses the whole limit, the answer ends with finish_reason: length and no content. Choose a suitable total-output limit and a lower effort, or use strict off on a supporting route. An approximate reasoning.max_tokens mapping cannot guarantee room for the answer. Unsetting the limit is not a spending cap.