Skip to main content

Thinking / Reasoning

Models that support thinking output a reasoning process before generating the final answer. Different providers use different request fields to trigger thinking (thinking.type / reasoning_effort / thinkingConfig / enable_thinking), but thinking content is uniformly returned via the reasoning_content field in the response (or the thinking content block in the Anthropic Messages protocol).

For a complete list of thinking-capable models, see the Model Catalog — models with thinkingSupport: true on their card support thinking, and the thinkingLink on each card links to the corresponding section on this page.

Configuration Parameters × Provider Matrix​

Provider / Model RangeApplicable APITrigger ParameterDefault BehaviorCan Be Fully DisabledThinking Intensity ControlThinking Output Field
Anthropic Claude 4.x / 5.xv1/messages / v1/chat/completionsthinking.typeOff by default; Sonnet 5 defaults to adaptive✅budget_tokens or output_config.effortthinking content block / reasoning_content
Azure OpenAI GPT-5.x / o1·o3·o4Must use v1/responses — reasoning cannot be controlled via v1/chat/completions, and the reasoning process is not returnedreasoning.effort (see Responses API)Determined by the model itselfModel-dependentGPT-5.6: none / minimal / low / medium / high / xhigh / max; other models per Model CatalogVisible only under v1/responses
Google Gemini 3+v1/chat/completionsthinkingConfig.thinkingLevelOn by default; default intensity varies by modelCannot be disabled for some modelsMINIMAL / LOW / MEDIUM / HIGHreasoning_content (requires includeThoughts)
Google Gemini 2.5v1/chat/completionsthinkingConfig.thinkingBudgetAuto (up to 8,192 tokens)Flash / Flash-Lite can disable; Pro cannot-1 dynamic or explicit token budgetreasoning_content (requires includeThoughts)
DeepSeek V4v1/chat/completions / v1/messagesthinking.type + reasoning_effortOn (high)✅high / maxreasoning_content
Alibaba Qwen 3.xv1/chat/completions (some models also support v1/messages)enable_thinkingOn by default for thinking models✅—delta.reasoning_content (streaming only)
Doubao Seed 2.0v1/chat/completionsreasoning_effortmedium thinking✅ (minimal)minimal / low / medium / highdelta.reasoning_content (streaming)
Kimi K2 thinking / Grok 4 fast reasoningv1/chat/completionsNo configuration neededAlways on❌—reasoning_content

"Can Be Fully Disabled" means suppressing reasoning tokens for a given request via parameters without switching models. Refer to the Model Catalog card for per-model support details.

Azure OpenAI GPT-5.6​

  • Applicable API: v1/responses (recommended for reasoning); all three models also support standard chat and function calling via v1/chat/completions.
  • Applicable models: turing/gpt-5.6-sol / turing/gpt-5.6-terra / turing/gpt-5.6-luna.
  • Model aliases: gpt-5.6 resolves to turing/gpt-5.6-sol by default; the three full model names without the turing/ prefix also resolve to the corresponding platform models.
  • Reasoning intensity: none / minimal / low / medium / high / xhigh / max. max is supported only by the GPT-5.6 series; the platform default assistant uses medium.
{
  "model": "turing/gpt-5.6-sol",
  "input": "Analyze the major performance bottlenecks in this system design and provide verification steps.",
  "reasoning": {
    "effort": "max",
    "summary": "auto"
  }
}

max increases reasoning time and reasoning token consumption, and is suited for complex tasks that require deep verification. For routine requests, start with medium or high.

Anthropic Claude​

Trigger Parameters​

thinking.type        "enabled" | "adaptive" | "disabled" (default behavior varies by model)
thinking.budget_tokens  Integer 1–10000 (only valid when type="enabled", and must be < max_tokens)
thinking.display     "summarized" | "omitted" (only valid in adaptive mode)
output_config.effort "low" | "medium" | "high" | "max" | "xhigh" (only valid in adaptive mode; available values depend on the model)
  • enabled — Manual budget mode; the reasoning token limit is controlled by budget_tokens.
  • adaptive — The model automatically determines reasoning depth; intensity is controlled via output_config.effort.
  • disabled — Disables thinking (default).

Model Support Matrix

Modeltype: "enabled"type: "adaptive"
turing/claude-sonnet-5❌ Returns 400 if passed✅ On by default (can be disabled with disabled)
turing/claude-opus-4.8❌ Returns 400 if passed✅ Only supported mode (off by default, must be explicitly enabled)
turing/claude-opus-4.7❌ Returns 400 if passed✅ Only supported mode (off by default, must be explicitly enabled)
turing/claude-opus-4.6✅✅
turing/claude-sonnet-4.6✅✅
turing/claude-opus-4.5 / claude-4.5-sonnet / earlier✅ Only supported mode❌

Breaking Changes in New Models​

turing/claude-opus-4.7 / turing/claude-opus-4.8 / turing/claude-sonnet-5 introduce breaking changes compared to 4.6:

  • thinking.type: "enabled" is not supported. Passing enabled returns a 400 ("thinking.type.enabled" is not supported for this model).
  • Reasoning intensity is controlled via output_config.effort; budget_tokens is no longer used.
  • output_config.effort for Opus 4.8 only accepts low / medium / high; passing max / xhigh may return an upstream 500.
  • Default behavior differs: Sonnet 5 defaults to adaptive and can be disabled with disabled; Opus 4.7/4.8 defaults to off and requires explicitly passing thinking.type: "adaptive" to enable.
  • In adaptive mode, thinking.display defaults to omitted (only the signature is returned, not the full body). Pass summarized explicitly when you need to display thinking content.
  • These models reject non-default sampling parameters. Do not pass temperature / top_p / top_k in requests, as doing so may return a 400.

For a full comparison of adaptive mode and field semantics, see Provider Specifics → Anthropic Adaptive Thinking.

Example​

{
  "model": "turing/claude-opus-4.8",
  "max_tokens": 16000,
  "thinking": {
    "type": "adaptive",
    "display": "summarized"
  },
  "output_config": {
    "effort": "high"
  },
  "messages": [
    { "role": "user", "content": "Explain why the sum of two even numbers is always even." }
  ]
}

Under the v1/messages protocol, the response includes a thinking content block; under v1/chat/completions, the reasoning content is populated in delta.reasoning_content.

Google Gemini​

Gemini passes Google's native thinkingConfig directly through Turing's Chat Completions endpoint. This section covers only the official fields, organized by model series using either thinkingLevel or thinkingBudget.

thinkingConfig.includeThoughts only controls whether a thinking summary is returned — it is not a toggle for enabling or disabling thinking. Even without returning a thinking summary, the model may still generate and bill for thinking tokens.

Gemini 3 and Later​

  • Official docs: Gemini Thinking / Vertex AI GenerationConfig
  • Applicable API: v1/chat/completions
  • Applicable models: Refer to the Gemini 3 / 3.1 / 3.5 / 3.6 thinking models in Model Catalog → Gemini.
  • Control field: thinkingConfig.thinkingLevel
  • Do not mix: thinkingLevel and thinkingBudget cannot appear in the same Gemini 3+ request.
  • Responses may include a thought_signature, which must be passed back verbatim in multi-turn conversations or function calling (see Thought Signatures below).

thinkingLevel uses Google REST/JSON-style uppercase enum values:

ValueUse Case
MINIMALMinimize thinking tokens; supported only by some Flash / Flash-Lite / Image models
LOWSimple tasks, high throughput, low latency
MEDIUMModerate complexity tasks; balanced quality and latency
HIGHComplex reasoning, multi-step planning, code analysis, function calling, etc.

Supported thinkingLevel values and defaults vary across Gemini 3+ models. Turing model names are defined in Model Catalog → Gemini; select based on the corresponding upstream model family:

Upstream Model FamilySupported thinkingLevelDefault
Gemini 3.6 FlashMINIMAL / LOW / MEDIUM / HIGHMEDIUM
Gemini 3.5 FlashMINIMAL / LOW / MEDIUM / HIGHMEDIUM
Gemini 3.1 ProLOW / MEDIUM / HIGHHIGH
Gemini 3.1 Flash-LiteMINIMAL / LOW / MEDIUM / HIGHMINIMAL
Gemini 3.1 Flash ImageMINIMAL / HIGHMINIMAL
Gemini 3 FlashMINIMAL / LOW / MEDIUM / HIGHHIGH
Gemini 3 ProLOW / MEDIUM / HIGHHIGH
Gemini 3 Pro ImageHIGHHIGH

Gemini 3 Pro / 3.1 Pro cannot disable thinking. MINIMAL is only available for some Flash / Flash-Lite / Image models.

Temperature Restriction

Gemini 3 / 3.1 requires temperature to remain at its default value of 1.0. Setting it below 1.0 may cause the model to enter an infinite loop or significantly degrade reasoning performance.

{
  "model": "turing/gemini-3.1-pro-latest",
  "messages": [
    { "role": "user", "content": "Solve x^2 + 5x + 6 = 0 step by step." }
  ],
  "thinkingConfig": {
    "includeThoughts": true
  }
}

OpenAI Python SDK usage:

response = client.chat.completions.create(
    model="turing/gemini-3.6-flash",
    messages=[{"role": "user", "content": "Analyze the most likely root cause in this log"}],
    extra_body={
        "thinkingConfig": {
            "includeThoughts": True,
        }
    },
)

Thought Signatures (Required for Multi-Turn / Function Calling)​

When using function calling or multi-turn conversations with Gemini 3+, you must pass back the thought_signature returned in the response verbatim in subsequent turns to maintain the model's reasoning state. Omitting it will return a 400.

📖 Vertex AI Thought Signatures Official Docs

Field Location

  • Function calling response: tool_calls[0].provider_specific_fields.thought_signature
  • Multi-turn conversation response: message.provider_specific_fields.thought_signature

SDK Auto-Handling (Recommended)

# Turn 1
response_1 = client.chat.completions.create(
    model="turing/gemini-3-pro-latest",
    messages=[{"role": "user", "content": "Weather in Tokyo?"}],
    tools=[...],
)

# Turn 2 — reuse response_1.choices[0].message directly; the SDK preserves thought_signature automatically
messages = [
    {"role": "user", "content": "Weather in Tokyo?"},
    response_1.choices[0].message,            # Do not destructure; keep the whole object
    {"role": "tool", "content": '{"temp": 30}', "tool_call_id": "..."},
]
client.chat.completions.create(
    model="turing/gemini-3-pro-latest",
    messages=messages,
    tools=[...],
)

Manually Constructing a Message (cURL / Custom Flow)

{
  "role": "assistant",
  "content": null,
  "tool_calls": [{
    "id": "call_abc",
    "type": "function",
    "function": {"name": "get_weather", "arguments": "{\"location\": \"Tokyo\"}"},
    "provider_specific_fields": {
      "thought_signature": "eyJ0aGlua2luZ19zdGF0ZSI6Li4ufQ=="
    }
  }]
}

thought_signature must not be modified — any alteration will result in a 400. Multi-turn conversations (without tools) also require preserving it; the field is located at message.provider_specific_fields.thought_signature.

For complete SDK examples, multi-turn conversation scenarios, and common errors, see Provider Specifics → Gemini Thought Signatures.

Gemini 2.5 Series​

Gemini 2.5 and earlier thinking models use thinkingConfig.thinkingBudget; do not pass thinkingLevel:

ModelAvailable BudgetDefault
Gemini 2.5 Flash0 disables thinking content, -1 dynamic, 1–24576 explicit limitAuto (up to 8,192 tokens)
Gemini 2.5 Flash-Lite0 disables thinking content, -1 dynamic, 512–24576 explicit limitAuto (up to 8,192 tokens)
Gemini 2.5 Pro-1 dynamic, 128–32768 explicit limitAuto (up to 8,192 tokens)

thinkingBudget is a soft limit; actual thinking tokens may vary. 0 is only available for Flash / Flash-Lite and suppresses thought content output; the model's final answer may still contain reasoning-style text. Gemini 2.5 Pro cannot disable thinking.

{
  "model": "turing/gemini-2.5-flash",
  "messages": [
    { "role": "user", "content": "Solve x^2 + 5x + 6 = 0 step by step." }
  ],
  "thinkingConfig": {
    "includeThoughts": true
  }
}

DeepSeek​

V4 Series (Primary)​

Thinking is on by default and can be explicitly disabled or adjusted.

thinking.type        "enabled" (default) | "disabled"
reasoning_effort     "high" (default) | "max"
                     Legacy values "low" / "medium" → automatically mapped to "high"
                     Legacy value "xhigh" → automatically mapped to "max"
  • max is suited for complex agent scenarios such as Claude Code and OpenCode; passing it explicitly in regular requests also takes effect.
  • When thinking is enabled, temperature / top_p / presence_penalty / frequency_penalty have no effect (backward compatible — no error is raised).
{
  "model": "deepseek-v4-pro",
  "messages": [{ "role": "user", "content": "..." }],
  "thinking": { "type": "enabled" },
  "reasoning_effort": "max"
}

Legacy Series​

  • turing/deepseek-r1 / turing/deepseek-r1-0528 — No configuration needed; deep reasoning is always on (see Always-On Thinking Models below).
  • turing/deepseek-v3-2 — Off by default; enable explicitly with thinking.type: "enabled".

Alibaba Qwen​

enable_thinking   Boolean (defaults to true for thinking models)
                  Pass in extra_body when using the OpenAI SDK
Streaming Restriction

Qwen3 thinking models support streaming only — stream=true is required. Non-streaming requests will be rejected.

Thinking content is returned in the delta.reasoning_content field, which is a separate channel from delta.content.

curl -N $TURING_BASE_URL/chat/completions \
  -H "Authorization: Bearer $TURING_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3-14b",
    "messages": [{ "role": "user", "content": "Explain the basic principles of quantum computing." }],
    "stream": true,
    "enable_thinking": true
  }'

Doubao​

reasoning_effort   "minimal" — Disables thinking; answers directly
                   "low"     — Lightweight thinking; prioritizes speed
                   "medium" (default) — Balanced mode
                   "high"    — Deep thinking; handles complex problems

Reasoning content is returned in the delta.reasoning_content field (streaming mode). max_tokens does not apply to the thinking portion; the total output limit is controlled by max_completion_tokens (0–65536), which includes both the response and reasoning.

{
  "model": "doubao-seed-2-0-pro-260215",
  "messages": [{ "role": "user", "content": "..." }],
  "stream": true,
  "reasoning_effort": "high"
}

Always-On Thinking Models (No Configuration Required)​

  • Applicable API: v1/chat/completions

These models require no parameters to activate thinking. The platform executes thinking automatically and populates the reasoning content into reasoning_content. Refer to the provider sections and thinking capability indicators in the Model Catalog for specific models:

OpenAI / Azure​

Reasoning Is Uncontrollable and Invisible Under chat/completions

Thinking in GPT-5.x, o1, o3, and o4 reasoning models is built into the model, but when using the v1/chat/completions protocol:

  • The reasoning_effort parameter has no effect (writing it in the request does not change thinking intensity)
  • Reasoning content is not returned in the response (reasoning_content is always empty; only the final answer is available)

To control thinking intensity and view the reasoning process, you must use the v1/responses protocol.

Use the reasoning.effort parameter to control thinking depth, and reasoning.summary to control whether the thinking summary is returned. Full value range:

reasoning.effort   "none" | "minimal" | "low" | "medium" | "high" | "xhigh"
                   Higher values mean deeper thinking, more reasoning tokens, and higher costs
reasoning.summary  "auto" | null
                   null means the thinking summary is not returned (reasoning tokens are still billed)

For complete configuration, incompatible fields, and response fields:

➡️ Responses API → Reasoning Mode

Stateful Thinking: GPT-5.1 / 5.2 thinking models under the Responses protocol can reuse thinking state across turns via tags: ["stateful"]. See Responses API → Stateful Thinking.

When thinking is enabled under v1/responses, parameters such as temperature / top_p will also be rejected. Reasoning token billing: Reasoning tokens are counted under output_tokens; some models have a separate output_cost_per_reasoning_token rate (see Billing & Usage).

How Thinking Content Is Returned​

Quick Field Reference​

ProtocolFieldDescription
v1/chat/completions (non-streaming)choices[].message.reasoning_contentFull thinking content
v1/chat/completions (streaming)choices[].delta.reasoning_contentThinking increments (separate channel from delta.content)
v1/messages (non-streaming, Claude)Block with type: "thinking" in content[] arrayContains text and signature
v1/messages (streaming, Claude)content_block_delta event, delta.type: "thinking_delta"Thinking increments
Billingusage.completion_tokens_details.reasoning_tokensReasoning token count, billed as output

Streaming Parsing Notes​

  • reasoning_content and content are two independent fields that must be accumulated separately.
  • Thinking content is typically returned before the final reply, but there is no guarantee that thinking finishes entirely before content begins.
  • When setting provider-specific fields (e.g., thinkingConfig / enable_thinking) via the OpenAI SDK: use extra_body in Python, use as any / @ts-expect-error to bypass types in Node.js, and use additionalBodyProperties in Java.

Notes​

  1. Thinking token billing — The reasoning process is billed as output tokens and shares the max_tokens limit with visible output. See Usage & Billing.
  2. New Claude models reject sampling parameters — Opus 4.7 / 4.8 and Sonnet 5 reject non-default temperature / top_p / top_k; for 4.6 and earlier models, avoid passing these parameters when thinking.type: "enabled" / "adaptive" is set.
  3. Qwen thinking models require streaming — Non-streaming requests will be rejected.
  4. Gemini uses native thinkingConfig — Use thinkingLevel for Gemini 3+, and thinkingBudget for Gemini 2.5; do not mix thinkingLevel and thinkingBudget.
  5. Gemini 3+ multi-turn / function calling requires passing back thought_signature verbatim — See Gemini Thought Signatures.
  6. DeepSeek V4 sampling parameters are ignored when thinking is enabled — temperature / top_p / presence_penalty / frequency_penalty have no effect but do not raise errors.
  7. Doubao thinking variants cannot be disabled — Model names containing "thinking" represent always-on thinking; to disable, switch to a non-thinking variant in the same series. Refer to the Model List for specific models.