Skip to main content
The reasoning parameter accepts effort and summary fields. Reasoning output appears as dedicated reasoning output items separate from text content.

​
Prerequisites

  • An Auriko API key
  • Python 3.10+ with the OpenAI SDK (pip install openai) or the Auriko SDK (pip install auriko)
    • OR Node.js 18+ with the OpenAI SDK (npm install openai) or @auriko/sdk (npm install @auriko/sdk)

​
Set reasoning effort

Set the reasoning effort level: 
import os
from openai import OpenAI

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

response = client.responses.create(
    model="claude-sonnet-4-6",
    input="What is the derivative of x^3 + 2x^2 - 5x + 3?",
    reasoning={"effort": "high"}
)

print(response.output_text)
Effort levels: none, minimal, low, medium, high, xhigh, max, off. Auriko normalizes these levels across providers. See Extensions and Thinking for the provider support table.

​
Access reasoning summaries

Request reasoning summaries with the summary field (or its alias generate_summary): 
import os
from openai import OpenAI

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

response = client.responses.create(
    model="o3-mini",
    input="Explain why the sky is blue",
    reasoning={"effort": "high", "summary": "detailed"}
)

for item in response.output:
    if item.type == "reasoning":
        for block in item.summary:
            print(f"Reasoning: {block.text}")
    elif item.type == "message":
        for part in item.content:
            print(f"Answer: {part.text}")
Not all models provide reasoning summaries. Check the summary array on the reasoning output item in the response. See Extensions and Thinking for which models support reasoning summaries.

​
Stream reasoning

Stream reasoning summary events: 
import os
from openai import OpenAI

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

stream = client.responses.create(
    model="o3-mini",
    input="What is 25 * 37?",
    reasoning={"effort": "high", "summary": "detailed"},
    stream=True
)

for event in stream:
    if event.type == "response.reasoning_summary_text.delta":
        print(f"[reasoning] {event.delta}", end="", flush=True)
    elif event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

​
Map parameters

Chat CompletionsResponse API
reasoning_effort: "high"reasoning: {effort: "high"}
choices[0].message.reasoning_contentoutput[].type: "reasoning" with summary blocks
reasoning_effort in extra_body (OpenAI SDK)reasoning is a native parameter (OpenAI SDK)
The OpenAI SDK supports reasoning as a top-level parameter on client.responses.create(). You don’t need extra_body for reasoning in the Response API.

​
Preserve reasoning across turns

Include the full reasoning output item (with encrypted_content if present) in subsequent input. Models use the encrypted content to maintain reasoning context. Omitting it starts reasoning from scratch. 
final = client.responses.create(
    model="o3-mini",
    input=[
        {"type": "message", "role": "user", "content": "Solve: x^2 - 5x + 6 = 0"},
        *[item.model_dump(exclude={"status"}) for item in response.output],
        {"type": "message", "role": "user", "content": "Now verify the answer by substitution"}
    ],
    reasoning={"effort": "high", "summary": "detailed"}
)
The same pattern applies in TypeScript with await client.responses.create() and spreading response.output. See Extensions and Thinking for effort normalization, provider support, and sampling constraints.