Reasoning and thinking

Planck normalizes reasoning controls across supported provider endpoints. Use the request shape that matches your SDK; Planck translates it to the selected provider’s format.

Client format	Reasoning controls
OpenAI-compatible	`reasoning_effort` and `include_reasoning`
Anthropic-compatible	`thinking` and `output_config.effort`

Reasoning support and accepted effort values are model- and provider-specific. Check the model’s Request Lab at inquantum.ai/models, or inspect its endpoint capabilities with GET /v1/models/{model_id}.

OpenAI-compatible requests

Replace <provider>/<model> with a model ID from the Models page. The available effort values depend on the selected endpoint.

cURL

curl https://api.inquantum.ai/v1/chat/completions \
  -H "Authorization: Bearer $PLANCK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<provider>/<model>",
    "max_tokens": 8192,
    "reasoning_effort": "high",
    "include_reasoning": true,
    "messages": [
      {"role": "user", "content": "Compare two approaches to this problem."}
    ]
  }'

OpenAI Python SDK

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["PLANCK_API_KEY"],
    base_url="https://api.inquantum.ai/v1",
)

response = client.chat.completions.create(
    model="<provider>/<model>",
    max_tokens=8192,
    reasoning_effort="high",
    extra_body={"include_reasoning": True},
    messages=[
        {"role": "user", "content": "Compare two approaches to this problem."}
    ],
)

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

include_reasoning is a Planck-compatible extension, so the OpenAI Python SDK example sends it through extra_body.

Anthropic-compatible requests

Use adaptive thinking and optionally set an effort. Planck translates these fields for the selected model and provider.

Python SDK

import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.environ["PLANCK_API_KEY"],
    base_url="https://api.inquantum.ai/anthropic",
)

message = client.messages.create(
    model="<provider>/<model>",
    max_tokens=8192,
    thinking={"type": "adaptive"},
    output_config={"effort": "high"},
    messages=[
        {"role": "user", "content": "Compare two approaches to this problem."}
    ],
)

for block in message.content:
    if block.type == "thinking":
        print(block.thinking)
    elif block.type == "text":
        print(block.text)

The Anthropic SDK calls its credential option api_key, but the value above is your Planck API key. The SDK sends it as x-api-key, which Planck accepts for authentication.

cURL

curl https://api.inquantum.ai/anthropic/v1/messages \
  -H "x-api-key: $PLANCK_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "<provider>/<model>",
    "max_tokens": 8192,
    "thinking": {"type": "adaptive"},
    "output_config": {"effort": "high"},
    "messages": [
      {"role": "user", "content": "Compare two approaches to this problem."}
    ]
  }'

Anthropic thinking mappings

Desired behavior	Anthropic-compatible request fields
Provider default	`thinking: {"type": "adaptive"}`
Explicit effort	`thinking: {"type": "adaptive"}` plus `output_config: {"effort": "low" \| "medium" \| "high"}`
Think without returning reasoning	`thinking: {"type": "adaptive", "display": "omitted"}`
Disable thinking	`thinking: {"type": "disabled"}`

The compatibility route does not accept manual thinking budgets such as thinking: {"type": "enabled", "budget_tokens": 2048}. For effort-based models, use adaptive thinking with output_config.effort; an unsupported value or mode returns 400.

`max_tokens` behavior

Anthropic Messages requires max_tokens. The Anthropic SDK also requires it, and Planck does not add a default for an Anthropic-compatible request.

For POST /v1/chat/completions, max_tokens is optional. If you omit both max_tokens and max_completion_tokens, Planck leaves the output limit unspecified and the selected provider applies its own default. A model’s advertised maximum output is a ceiling, not an automatic default.

Bring your own Anthropic key

For normal credit usage or a provider key already stored in Planck, the single PLANCK_API_KEY setup above is sufficient. To send an Anthropic provider key explicitly with the SDK, keep the Planck key in api_key and add the provider key separately:

client = Anthropic(
    api_key=os.environ["PLANCK_API_KEY"],
    base_url="https://api.inquantum.ai/anthropic",
    default_headers={
        "X-Provider-Key": os.environ["ANTHROPIC_API_KEY"],
    },
)

See Provider routing and BYOK for billing-mode selection and stored provider keys.

Get Started

Models & Inference

Reliability & Controls

Observability

Prompt Management

Integrations

Enterprise

Reasoning and thinking

OpenAI-compatible requests

cURL

OpenAI Python SDK

Anthropic-compatible requests

Python SDK

cURL

Anthropic thinking mappings

`max_tokens` behavior

Bring your own Anthropic key

​OpenAI-compatible requests

​cURL

​OpenAI Python SDK

​Anthropic-compatible requests

​Python SDK

​cURL

​Anthropic thinking mappings

​max_tokens behavior

​Bring your own Anthropic key

OpenAI-compatible requests

cURL

OpenAI Python SDK

Anthropic-compatible requests

Python SDK

cURL

Anthropic thinking mappings

`max_tokens` behavior

Bring your own Anthropic key