Reasoning - Auriko

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)

import OpenAI from "openai";

const client = new OpenAI({
    apiKey: process.env.AURIKO_API_KEY,
    baseURL: "https://api.auriko.ai/v1",
});

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

console.log(response.output_text);

import os
from auriko import Client

client = Client(
    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)

import { Client } from "@auriko/sdk";

const client = new Client({
    apiKey: process.env.AURIKO_API_KEY,
    baseUrl: "https://api.auriko.ai/v1",
});

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

console.log(response.output_text);

curl https://api.auriko.ai/v1/responses \
  -H "Authorization: Bearer $AURIKO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "input": "What is the derivative of x^3 + 2x^2 - 5x + 3?",
    "reasoning": {"effort": "high"}
  }'

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}")

import OpenAI from "openai";

const client = new OpenAI({
    apiKey: process.env.AURIKO_API_KEY,
    baseURL: "https://api.auriko.ai/v1",
});

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

for (const item of response.output) {
    if (item.type === "reasoning") {
        for (const block of item.summary) {
            console.log(`Reasoning: ${block.text}`);
        }
    } else if (item.type === "message") {
        for (const part of item.content) {
            console.log(`Answer: ${part.text}`);
        }
    }
}

import os
from auriko import Client

client = Client(
    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}")

import { Client } from "@auriko/sdk";

const client = new Client({
    apiKey: process.env.AURIKO_API_KEY,
    baseUrl: "https://api.auriko.ai/v1",
});

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

for (const item of response.output) {
    if (item.type === "reasoning") {
        for (const block of item.summary) {
            console.log(`Reasoning: ${block.text}`);
        }
    } else if (item.type === "message") {
        for (const part of item.content) {
            console.log(`Answer: ${part.text}`);
        }
    }
}

curl https://api.auriko.ai/v1/responses \
  -H "Authorization: Bearer $AURIKO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "o3-mini",
    "input": "Explain why the sky is blue",
    "reasoning": {"effort": "high", "summary": "detailed"}
  }'

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)

import OpenAI from "openai";

const client = new OpenAI({
    apiKey: process.env.AURIKO_API_KEY,
    baseURL: "https://api.auriko.ai/v1",
});

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

for await (const event of stream) {
    if (event.type === "response.reasoning_summary_text.delta") {
        process.stdout.write(`[reasoning] ${event.delta}`);
    } else if (event.type === "response.output_text.delta") {
        process.stdout.write(event.delta);
    }
}

import os
from auriko import Client

client = Client(
    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)

import { Client } from "@auriko/sdk";

const client = new Client({
    apiKey: process.env.AURIKO_API_KEY,
    baseUrl: "https://api.auriko.ai/v1",
});

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

for await (const event of stream) {
    if (event.type === "response.reasoning_summary_text.delta") {
        process.stdout.write(`[reasoning] ${event.delta}`);
    } else if (event.type === "response.output_text.delta") {
        process.stdout.write(event.delta);
    }
}

curl --no-buffer https://api.auriko.ai/v1/responses \
  -H "Authorization: Bearer $AURIKO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "o3-mini",
    "input": "What is 25 * 37?",
    "reasoning": {"effort": "high", "summary": "detailed"},
    "stream": true
  }'

Map parameters

Chat Completions	Response API
`reasoning_effort: "high"`	`reasoning: {effort: "high"}`
`choices[0].message.reasoning_content`	`output[].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.

​Prerequisites

​Set reasoning effort

​Access reasoning summaries

​Stream reasoning

​Map parameters

​Preserve reasoning across turns