> ## Documentation Index
> Fetch the complete documentation index at: https://docs.auriko.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Reasoning

> Control reasoning effort and access reasoning summaries in Response API output

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](https://auriko.ai/signup?redirectTo=%2Fdashboard%3Ftab%3Dapi-keys)
* 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:

<CodeGroup>
  ```python Python OpenAI theme={null}
  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)
  ```

  ```typescript TypeScript OpenAI theme={null}
  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);
  ```

  ```python Python Auriko theme={null}
  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)
  ```

  ```typescript TypeScript Auriko theme={null}
  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);
  ```

  ```bash cURL theme={null}
  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"}
    }'
  ```
</CodeGroup>

Effort levels: `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`, `off`. Auriko normalizes these levels across providers. See [Extensions and Thinking](/guides/extensions-and-thinking#check-provider-support) for the provider support table.

## Access reasoning summaries

Request reasoning summaries with the `summary` field (or its alias `generate_summary`):

<CodeGroup>
  ```python Python OpenAI theme={null}
  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}")
  ```

  ```typescript TypeScript OpenAI theme={null}
  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}`);
          }
      }
  }
  ```

  ```python Python Auriko theme={null}
  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}")
  ```

  ```typescript TypeScript Auriko theme={null}
  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}`);
          }
      }
  }
  ```

  ```bash cURL theme={null}
  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"}
    }'
  ```
</CodeGroup>

Not all models provide reasoning summaries. Check the `summary` array on the `reasoning` output item in the response. See [Extensions and Thinking](/guides/extensions-and-thinking#check-provider-support) for which models support reasoning summaries.

## Stream reasoning

Stream reasoning summary events:

<CodeGroup>
  ```python Python OpenAI theme={null}
  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)
  ```

  ```typescript TypeScript OpenAI theme={null}
  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);
      }
  }
  ```

  ```python Python Auriko theme={null}
  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)
  ```

  ```typescript TypeScript Auriko theme={null}
  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);
      }
  }
  ```

  ```bash cURL theme={null}
  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
    }'
  ```
</CodeGroup>

## 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.

```python theme={null}
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](/guides/extensions-and-thinking) for effort normalization, provider support, and sampling constraints.