Reasoning

Solve harder problems by giving the model more time to think. Muse Spark is a reasoning model: it generates internal reasoning tokens before visible output, and you control how much with reasoning_effort.

How it works

When you send a request, the model works through the problem internally first. That reasoning stays private and does not appear in the response body. Reasoning tokens count toward your output-token budget (max_tokens on Chat Completions, max_output_tokens on the Responses API) and toward billed completion tokens.

Set reasoning_effort to choose depth:

Value	Behavior
`"none"`	Disables reasoning. Not supported by Muse Spark: returns `HTTP 400`.
`"minimal"`	Shortest reasoning pass.
`"low"`	Light reasoning.
`"medium"`	Moderate depth.
`"high"`	Deep reasoning.
`"xhigh"`	Deeper reasoning.
`"max"`	Extended reasoning beyond `"xhigh"`. Standard-tier `muse-spark-1.3` only; not available on Contributor-tier models.

Higher effort means more reasoning — and more reasoning tokens, latency, and cost. "none" disables reasoning entirely, which Muse Spark does not support.

When you omit the parameter, the model still reasons at a model-determined level.

Usage

Chat Completions

Send reasoning_effort at the top level of a chat completion request:

python
import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.meta.ai/v1",
    api_key=os.environ["MODEL_API_KEY"],
)
response = client.chat.completions.create(
    model="muse-spark-1.3",
    reasoning_effort="high",
    messages=[
        {
            "role": "user",
            "content": "Prove that the square root of 2 is irrational.",
        },
    ],
)
print(response.model_dump_json(indent=2))

typescript
import OpenAI from 'openai';
const apiKey = process.env.MODEL_API_KEY;
if (!apiKey) {
  throw new Error('MODEL_API_KEY is not set');
}
const client = new OpenAI({
  baseURL: 'https://api.meta.ai/v1',
  apiKey,
});
const response = await client.chat.completions.create({
  model: 'muse-spark-1.3',
  reasoning_effort: 'high',
  messages: [
    {
      role: 'user',
      content: 'Prove that the square root of 2 is irrational.',
    },
  ],
});
console.log(JSON.stringify(response, null, 2));

python
import json
import os
import requests
response = requests.post(
    "https://api.meta.ai/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {os.environ['MODEL_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "muse-spark-1.3",
        "reasoning_effort": "high",
        "messages": [
            {
                "role": "user",
                "content": "Prove that the square root of 2 is irrational.",
            },
        ],
    },
)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))

shell
curl -X POST "https://api.meta.ai/v1/chat/completions" \
  -H "Authorization: Bearer $MODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "muse-spark-1.3",
  "reasoning_effort": "high",
  "messages": [
    {
      "role": "user",
      "content": "Prove that the square root of 2 is irrational."
    }
  ]
}'

Responses API

On the Responses API, nest the same control as reasoning.effort:

python
import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.meta.ai/v1",
    api_key=os.environ["MODEL_API_KEY"],
)
response = client.responses.create(
    model="muse-spark-1.3",
    reasoning={
        "effort": "high",
    },
    input="Prove that the square root of 2 is irrational.",
)
print(response.model_dump_json(indent=2))

typescript
import OpenAI from 'openai';
const apiKey = process.env.MODEL_API_KEY;
if (!apiKey) {
  throw new Error('MODEL_API_KEY is not set');
}
const client = new OpenAI({
  baseURL: 'https://api.meta.ai/v1',
  apiKey,
});
const response = await client.responses.create({
  model: 'muse-spark-1.3',
  reasoning: {
    effort: 'high',
  },
  input: 'Prove that the square root of 2 is irrational.',
});
console.log(JSON.stringify(response, null, 2));

python
import json
import os
import requests
response = requests.post(
    "https://api.meta.ai/v1/responses",
    headers={
        "Authorization": f"Bearer {os.environ['MODEL_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "muse-spark-1.3",
        "reasoning": {
            "effort": "high",
        },
        "input": "Prove that the square root of 2 is irrational.",
    },
)
response.raise_for_status()
print(json.dumps(response.json(), indent=2))

shell
curl -X POST "https://api.meta.ai/v1/responses" \
  -H "Authorization: Bearer $MODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "muse-spark-1.3",
  "reasoning": {
    "effort": "high"
  },
  "input": "Prove that the square root of 2 is irrational."
}'

Log probabilities

Muse Spark is a reasoning model, so logprobs is not supported. logprobs: true (Chat Completions) and include: ["message.output_text.logprobs"] (Responses API) both return HTTP 400.

Multi-turn reasoning

You can carry reasoning context across turns so follow-ups build on earlier thinking. How you preserve it depends on the endpoint.

Responses API

Chain turns with previous_response_id. The server keeps reasoning context for you:

json
{
  "model": "muse-spark-1.3",
  "reasoning": {"effort": "high"},
  "input": "Now extend the proof to show that the square root of 3 is also irrational.",
  "previous_response_id": "resp_abc123"
}

For stateless replay, where you manage history yourself instead of chaining response IDs, request the model's encrypted reasoning with include: ["reasoning.encrypted_content"] and replay it as a reasoning input item on the next turn. See reasoning items in multi-turn input for the full pattern.

Chat Completions

Chat Completions cannot carry reasoning across turns for external API keys. Assistant messages expose a reasoning_content field, but it holds the model's private chain of thought and is redacted to empty before the response reaches an external caller, so there is nothing to replay and each turn reasons from scratch. It is populated only for internal callers holding the internal:private_cot attribute. Do not rely on reasoning_content for multi-turn continuity on this endpoint. For multi-step and agentic workloads where preserving chain of thought matters, use the Responses API above, which replays reasoning through encrypted content or previous_response_id.

Reasoning summaries

The raw chain of thought stays private, but on the Responses API you can request a natural-language summary of it. Set reasoning.summary to "auto", "concise", or "detailed":