DeepSeek Thinking Mode: raciocínio, streaming e tools

Documentação reconferida em 23 de agosto de 2026. O Thinking Mode vem ativado por padrão, com esforço high. Em Chat Completions, reasoning_effort publica low, high e max; por compatibilidade, medium e xhigh são mapeados para high. O mapeamento oficial é idêntico em V4 Flash e V4 Pro. As chamadas autenticadas abaixo continuam datadas de 29 de julho.

Resumo: no formato OpenAI Chat Completions, ative ou desative com thinking.type e controle o esforço com reasoning_effort. Flash e Pro usam o mesmo mapeamento oficial de esforço. Em tool loops com Thinking, preserve integralmente o reasoning_content da mensagem do assistente.

Teste histórico em 29/07/2026: Disabled, High e Max

Validamos os controles de Thinking Mode com deepseek-v4-flash. Os registros mostram uma consequência prática: max_tokens precisa comportar tanto o raciocínio quanto a resposta final.

Comparação do orçamento de tokens no Thinking Mode disabled, high e max da DeepSeek V4 Flash — Teste original de Thinking Mode em 29 de julho de 2026. max_tokens inclui raciocínio e resposta final; os limites exibidos pertencem à configuração testada.

Configuração	HTTP / fim	Resposta final	Reasoning	Entrada / saída / total
Disabled; teto 128	200 / stop	Presente	Ausente	31 / 24 / 55
High; teto 128	200 / length	Vazia	128 tokens	31 / 128 / 159
High; teto 384	200 / stop	Presente	155 tokens	31 / 165 / 196
Max; teto 384	200 / length	Vazia	384 tokens	110 / 384 / 494
Max; teto 768	200 / stop	Presente	392 tokens	110 / 412 / 522

O campo final vazio nas linhas de teto menor não significa que Thinking “falhou”: toda a saída permitida foi consumida por raciocínio. Ao elevar o teto no mesmo esforço, surgiu content e finish_reason mudou para stop.

Metodologia e limites

Modelo fixo: deepseek-v4-flash; chamadas não streaming; uma execução por configuração.
Disabled e High usaram o mesmo prompt decimal. As linhas Max mantiveram esse prompt, mas a API contabilizou 110 tokens de entrada; não inferimos a causa além do retorno observado.
Presença, caracteres ou tokens não medem a qualidade do raciocínio.
O conteúdo bruto de reasoning_content não é publicado.
Latências isoladas não sustentam comparação de velocidade.

Compare os modelos em V4 Flash vs Pro; veja aliases e formato em DeepSeek API.

Fonte oficial: Thinking Mode.

Aviso de independência: DeepSeek Português é um guia criado por terceiros. Este site não pertence, não é operado, patrocinado ou aprovado pela DeepSeek. Os links para a documentação oficial estão identificados ao longo da página.

O DeepSeek Thinking Mode faz o modelo gerar conteúdo de raciocínio antes de entregar a resposta final. Na API, esses dois resultados são separados: reasoning_content contém o conteúdo de raciocínio e content contém a resposta final destinada ao aplicativo ou usuário.

O modo pode ser útil em programação, matemática, planejamento, análise com várias restrições e agentes que usam ferramentas. Isso não garante uma resposta correta: aplicações de produção ainda precisam validar saídas, medir latência, acompanhar o consumo de tokens e testar o comportamento com casos reais.

Resposta rápida: use thinking: {"type":"enabled"} e escolha reasoning_effort entre low, high e max; o padrão é high. Para tarefas diretas, envie thinking: {"type":"disabled"}. Em Chat Completions com tools e Thinking, preserve reasoning_content e siga as restrições específicas dessa interface.

Modelos compatíveis com o Thinking Mode

Model ID	Entrada	Contexto	Saída máxima	Modos
`deepseek-v4-flash`	Texto	1 milhão	384 mil	Thinking e Non-Thinking
`deepseek-v4-pro`	Texto	1 milhão	384 mil	Thinking e Non-Thinking
`deepseek-v4-flash-vision-exp`	Texto e imagem	1 milhão	384 mil	Thinking e Non-Thinking

A tabela oficial de preços inclui os três modelos nos modos Thinking e Non-Thinking, com Thinking ativado por padrão. O mapeamento de esforço da seção seguinte é publicado explicitamente como idêntico para Flash e Pro; não extrapole medições históricas desta página para o Vision Exp.

A janela de contexto inclui a entrada e a saída gerada. Portanto, contexto de 1 milhão e saída máxima de 384 mil não são limites que podem ser simplesmente somados.

Em 29/07/2026, deepseek-reasoner ainda respondeu nesta conta e retornou V4 Flash com reasoning_content, embora ausente de GET /models. Não trate esse alias como V4 Pro nem como suporte garantido; controle Thinking explicitamente em um ID V4.

Parâmetros do DeepSeek Thinking Mode

Interface	Ativar ou desativar	Controle de esforço
OpenAI Chat Completions	`{"thinking":{"type":"enabled"}}` ou `disabled`	`reasoning_effort`
Anthropic Messages	Campo `thinking` suportado; `budget_tokens` é ignorado	`{"output_config":{"effort":"low/high/max"}}`
Responses API	`{"reasoning":{"effort":"none"}}` desativa	`reasoning.effort` com `low`, `high` ou `max`

O padrão continua sendo Thinking ativado com esforço high. Defina o comportamento explicitamente em produção e use a forma correspondente à interface chamada; um campo aceito por um formato pode ser ignorado em outro.

Como os níveis são mapeados em Flash e Pro

Esforço solicitado	V4 Flash: esforço efetivo	V4 Pro: esforço efetivo
`low`	`low`	`low`
`medium` — compatibilidade	`high`	`high`
`high`	`high`	`high`
`xhigh` — compatibilidade	`high`	`high`
`max`	`max`	`max`

O mapeamento oficial é idêntico nos dois modelos: low → low, medium → high, high → high, xhigh → high e max → max. A API publica low, high e max como valores de controle; medium e xhigh existem para compatibilidade. O protocolo histórico desta página testou High e Max apenas no Flash.

Esses níveis são configuração de serviço, não uma escala de qualidade comprovada. Não infira o esforço efetivo pelo tamanho de reasoning_content, pela latência de uma única chamada ou por uma resposta isolada. Fonte: Thinking Mode oficial.

Temperature e penalidades não controlam o Thinking

No Thinking Mode, temperature, top_p, presence_penalty e frequency_penalty não alteram o comportamento do raciocínio. A API pode aceitar esses campos por compatibilidade sem retornar erro, mas eles não produzem o ajuste esperado. Controle o modo com thinking e o esforço com reasoning_effort.

Exemplo básico em Node.js

O exemplo a seguir usa o fetch disponível no Node.js 18 ou superior. Guarde a API key exclusivamente no servidor. Não coloque a chave em JavaScript enviado ao navegador, aplicativo distribuído ou repositório público.

const apiKey = process.env.DEEPSEEK_API_KEY;

if (!apiKey) {
  throw new Error("Defina DEEPSEEK_API_KEY no ambiente do servidor.");
}

async function criarConclusao(body) {
  const response = await fetch(
    "https://api.deepseek.com/chat/completions",
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(body),
    }
  );

  if (!response.ok) {
    const detail = (await response.text()).slice(0, 500);
    throw new Error(`DeepSeek API ${response.status}: ${detail}`);
  }

  return response.json();
}

const data = await criarConclusao({
  model: "deepseek-v4-pro",
  messages: [
    {
      role: "system",
      content:
        "Entregue uma resposta final objetiva, com suposições e riscos.",
    },
    {
      role: "user",
      content:
        "Avalie os riscos de migrar este serviço para uma arquitetura distribuída.",
    },
  ],
  thinking: { type: "enabled" },
  reasoning_effort: "high",
  max_tokens: 4000,
});

const choice = data.choices?.[0];

if (!choice) {
  throw new Error("A API não retornou uma choice.");
}

if (choice.finish_reason !== "stop") {
  throw new Error(`Geração não concluída: ${choice.finish_reason}`);
}

const finalContent = choice.message?.content;

if (typeof finalContent !== "string" || !finalContent.trim()) {
  throw new Error("A API não retornou uma resposta final em content.");
}

console.log(finalContent);

console.log({
  promptTokens: data.usage?.prompt_tokens,
  completionTokens: data.usage?.completion_tokens,
  reasoningTokens:
    data.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
});

A aplicação normalmente deve apresentar message.content ao usuário. O campo reasoning_content está disponível para integração técnica, mas não precisa ser exibido na interface. Se a aplicação decidir registrá-lo, deve aplicar controles de acesso, retenção e proteção compatíveis com os usados para prompts e respostas.

Como desativar o Thinking Mode

const data = await criarConclusao({
  model: "deepseek-v4-flash",
  messages: [
    {
      role: "user",
      content: "Classifique esta solicitação como suporte ou vendas: ...",
    },
  ],
  thinking: { type: "disabled" },
  max_tokens: 300,
});

const choice = data.choices?.[0];

if (!choice || choice.finish_reason !== "stop") {
  throw new Error(
    `Resposta não concluída: ${choice?.finish_reason ?? "sem choice"}`
  );
}

console.log(choice.message.content);

Considere Non-Thinking para classificação simples, extração curta, reformatação, FAQ e tarefas de alto volume em que testes reais não mostrem ganho suficiente com o raciocínio. Definir disabled explicitamente evita depender do padrão do endpoint.

Streaming: separar raciocínio e resposta final

Com stream: true, a API retorna eventos Server-Sent Events. Fragmentos de raciocínio aparecem em delta.reasoning_content e fragmentos da resposta final em delta.content. Não presuma que todos os eventos contenham os dois campos.

Este exemplo processa uma resposta sem ferramentas. Streaming de tool calls também precisa reconstruir os deltas de tool_calls antes de executar uma função.

const apiKey = process.env.DEEPSEEK_API_KEY;

if (!apiKey) {
  throw new Error("Defina DEEPSEEK_API_KEY no servidor.");
}

const response = await fetch(
  "https://api.deepseek.com/chat/completions",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${apiKey}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "deepseek-v4-pro",
      messages: [
        {
          role: "user",
          content: "Identifique riscos neste plano de implantação: ...",
        },
      ],
      thinking: { type: "enabled" },
      reasoning_effort: "high",
      max_tokens: 4000,
      stream: true,
      stream_options: { include_usage: true },
    }),
  }
);

if (!response.ok) {
  const detail = (await response.text()).slice(0, 500);
  throw new Error(`DeepSeek API ${response.status}: ${detail}`);
}

if (!response.body) {
  throw new Error("O ambiente não disponibilizou o corpo do stream.");
}

const reader = response.body.getReader();
const decoder = new TextDecoder();

let buffer = "";
let reasoningContent = "";
let finalContent = "";
let finishReason = null;
let usage = null;
let receivedDone = false;

while (!receivedDone) {
  const { value, done } = await reader.read();

  if (done) break;

  buffer += decoder.decode(value, { stream: true });

  const events = buffer.split(/\r?\n\r?\n/);
  buffer = events.pop() ?? "";

  for (const event of events) {
    const payload = event
      .split(/\r?\n/)
      .filter((line) => line.startsWith("data:"))
      .map((line) => line.slice(5).trimStart())
      .join("\n");

    if (!payload) continue;

    if (payload === "[DONE]") {
      receivedDone = true;
      break;
    }

    const chunk = JSON.parse(payload);
    const choice = chunk.choices?.[0];

    if (chunk.usage) {
      usage = chunk.usage;
    }

    if (!choice) {
      // O chunk adicional de usage pode vir com choices vazio.
      continue;
    }

    const delta = choice.delta ?? {};

    if (typeof delta.reasoning_content === "string") {
      reasoningContent += delta.reasoning_content;
    }

    if (typeof delta.content === "string") {
      finalContent += delta.content;
      process.stdout.write(delta.content);
    }

    if (choice.finish_reason) {
      finishReason = choice.finish_reason;
    }
  }
}

if (finishReason === "length") {
  throw new Error("A resposta foi truncada pelo limite de tokens ou contexto.");
}

if (finishReason === "content_filter") {
  throw new Error("A resposta foi interrompida pelo filtro de conteúdo.");
}

if (finishReason === "insufficient_system_resource") {
  throw new Error("A geração foi interrompida por falta de recurso do sistema.");
}

if (finishReason !== "stop") {
  throw new Error(`Encerramento inesperado: ${finishReason}`);
}

if (!finalContent.trim()) {
  throw new Error("O stream terminou sem resposta final.");
}

console.log("\n\nResposta concluída.");
console.log({
  reasoningCharacters: reasoningContent.length,
  promptTokens: usage?.prompt_tokens,
  completionTokens: usage?.completion_tokens,
  reasoningTokens:
    usage?.completion_tokens_details?.reasoning_tokens ?? 0,
});

Quando stream_options.include_usage está ativado, a referência oficial de Chat Completion informa que um chunk adicional pode trazer as estatísticas totais com choices vazio. Por isso, o código verifica usage antes de tentar acessar a primeira choice.

Thinking Mode com tool calls

O Thinking Mode aceita ferramentas, mas o histórico exige tratamento específico. Quando o assistant solicita uma função, a mensagem intermediária precisa voltar integralmente nas solicitações seguintes do mesmo fluxo, incluindo reasoning_content e tool_calls.

A documentação de integração da própria DeepSeek registra três exigências importantes para V4 Thinking: não enviar tool_choice, preservar reasoning_content e manter content como valor não nulo na mensagem do assistant. Veja as notas oficiais de compatibilidade do DeepSeek V4.

Atenção: a API possui tool_choice para outros cenários, mas o DeepSeek V4 Thinking rejeita esse parâmetro. Quando tools está presente, omita tool_choice no pedido em Thinking Mode.

Tool loop completo e defensivo em Node.js

const apiKey = process.env.DEEPSEEK_API_KEY;

if (!apiKey) {
  throw new Error("Defina DEEPSEEK_API_KEY no servidor.");
}

async function criarConclusao(body) {
  const response = await fetch(
    "https://api.deepseek.com/chat/completions",
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(body),
    }
  );

  if (!response.ok) {
    const detail = (await response.text()).slice(0, 500);
    throw new Error(`DeepSeek API ${response.status}: ${detail}`);
  }

  return response.json();
}

const tools = [
  {
    type: "function",
    function: {
      name: "consultar_status_pedido",
      description: "Consulta o status de um pedido de demonstração.",
      parameters: {
        type: "object",
        properties: {
          pedido_id: {
            type: "string",
            description: "Identificador do pedido.",
          },
        },
        required: ["pedido_id"],
        additionalProperties: false,
      },
    },
  },
];

function executarFerramenta(call) {
  if (call?.type !== "function") {
    throw new Error("Tipo de tool não permitido.");
  }

  if (call.function?.name !== "consultar_status_pedido") {
    throw new Error("Função não permitida.");
  }

  let args;

  try {
    args = JSON.parse(call.function.arguments);
  } catch {
    throw new Error("Os argumentos da tool não são JSON válido.");
  }

  if (
    typeof args !== "object" ||
    args === null ||
    Array.isArray(args) ||
    typeof args.pedido_id !== "string" ||
    !args.pedido_id.trim()
  ) {
    throw new Error("pedido_id inválido.");
  }

  const allowedKeys = new Set(["pedido_id"]);

  for (const key of Object.keys(args)) {
    if (!allowedKeys.has(key)) {
      throw new Error(`Argumento não permitido: ${key}`);
    }
  }

  // Resultado simulado. Em produção, consulte um serviço autorizado.
  return {
    pedido_id: args.pedido_id,
    status: "em_separacao",
  };
}

const messages = [
  {
    role: "user",
    content: "Qual é o status do pedido DEMO-123?",
  },
];

let completed = false;

for (let round = 0; round < 5; round++) {
  const data = await criarConclusao({
    model: "deepseek-v4-pro",
    messages,
    tools,

    // Não envie tool_choice com V4 Thinking.
    thinking: { type: "enabled" },
    reasoning_effort: "high",
    max_tokens: 2000,
  });

  const choice = data.choices?.[0];

  if (!choice?.message) {
    throw new Error("A API não retornou uma mensagem do assistant.");
  }

  const assistant = choice.message;
  const toolCalls = Array.isArray(assistant.tool_calls)
    ? assistant.tool_calls
    : [];

  if (choice.finish_reason === "tool_calls") {
    if (toolCalls.length === 0) {
      throw new Error(
        "finish_reason informou tool_calls, mas nenhuma chamada foi retornada."
      );
    }

    if (typeof assistant.reasoning_content !== "string") {
      throw new Error(
        "reasoning_content está ausente no turno com tool calls."
      );
    }

    messages.push({
      role: "assistant",

      // A compatibilidade V4 exige content não nulo.
      content:
        typeof assistant.content === "string"
          ? assistant.content
          : "",

      // Preserve sem resumir, cortar ou reconstruir.
      reasoning_content: assistant.reasoning_content,
      tool_calls: toolCalls,
    });

    for (const call of toolCalls) {
      const result = executarFerramenta(call);

      messages.push({
        role: "tool",
        tool_call_id: call.id,
        content: JSON.stringify(result),
      });
    }

    continue;
  }

  if (choice.finish_reason === "stop") {
    if (toolCalls.length > 0) {
      throw new Error(
        "A resposta terminou com stop, mas ainda contém tool calls."
      );
    }

    const finalContent =
      typeof assistant.content === "string"
        ? assistant.content
        : "";

    if (!finalContent.trim()) {
      throw new Error("A API não retornou uma resposta final.");
    }

    console.log(finalContent);
    completed = true;
    break;
  }

  if (choice.finish_reason === "length") {
    throw new Error("A resposta foi truncada.");
  }

  if (choice.finish_reason === "content_filter") {
    throw new Error("A resposta foi interrompida pelo filtro de conteúdo.");
  }

  if (choice.finish_reason === "insufficient_system_resource") {
    throw new Error("A geração foi interrompida por falta de recurso.");
  }

  throw new Error(
    `finish_reason inesperado: ${choice.finish_reason}`
  );
}

if (!completed) {
  throw new Error("O tool loop excedeu o limite de cinco rodadas.");
}

Nesse fluxo, o modelo apenas produz o nome da função e os argumentos. Sua aplicação é responsável por executar a ferramenta. O exemplo usa um resultado simulado e não consulta um pedido real.

Em produção, valide todos os argumentos e aplique autenticação, autorização, timeout, idempotência, limites de custo e auditoria. Nunca execute diretamente um comando, consulta ou ação externa apenas porque foi sugerida pelo modelo. O guia oficial de Tool Calls também alerta que os argumentos gerados podem conter JSON inválido ou parâmetros não definidos.

Quando preservar reasoning_content no histórico

Situação	Regra
Resposta normal, sem tool call	O raciocínio do turno anterior não precisa ser reenviado. Se for incluído, a documentação informa que será ignorado na concatenação do próximo turno.
Mensagem intermediária que solicitou uma tool	Reenvie integralmente `reasoning_content`, `tool_calls` e um `content` não nulo em todos os pedidos seguintes daquele fluxo.
Resposta final após as tools	Apresente `content`. Não trate `reasoning_content` como substituto da resposta final.

O erro mais comum é reconstruir a mensagem do assistant apenas com role e content. Isso remove o estado necessário do turno de ferramenta e pode causar HTTP 400. Também não resuma ou edite reasoning_content antes de devolvê-lo à API dentro desse fluxo.

Como interpretar finish_reason

Valor	Significado	Ação segura
`stop`	A geração alcançou um ponto natural de parada ou uma sequência configurada	Trate `content` como resposta final
`tool_calls`	O modelo solicitou uma ou mais ferramentas	Valide, execute as funções permitidas e continue o loop
`length`	O limite de geração ou de contexto foi alcançado	Não apresente o conteúdo como resposta completa
`content_filter`	Parte da geração foi omitida por filtro	Não finja que houve conclusão normal
`insufficient_system_resource`	A inferência foi interrompida por falta de recurso do sistema	Registre a falha e aplique uma política limitada de nova tentativa

Verificar apenas a existência de message.content não é suficiente. A aplicação deve validar finish_reason antes de considerar uma solicitação concluída.

Quando usar Low, High, Max ou Non-Thinking

Modo	Ponto de partida	O que medir
Non-Thinking	Extração curta, classificação, reformatação, FAQ e baixa latência	Taxa de acerto, formato, latência e custo
Thinking + Low	Tarefas simples que ainda se beneficiam de raciocínio	Se melhora a precisão sem custo excessivo
Thinking + High	Debugging, planejamento, análise, código e decisões com restrições	Ganho de qualidade versus tokens e tempo
Thinking + Max	Problemas excepcionalmente difíceis e agentes complexos	Se o ganho é reproduzível e justifica o consumo adicional

Não existe uma configuração universalmente melhor. Crie um conjunto representativo de prompts, defina critérios de aprovação e compare as modalidades. Use o menor nível de esforço que atenda ao requisito de qualidade da aplicação.

Preços atuais: as tarifas de pico e fora de pico estão em vigor desde 16/08/2026, às 16:00 UTC. Desde 23/08/2026, sábado e domingo inteiros, definidos pelo horário de Pequim, são cobrados como fora de pico. Os testes de 29/07 permanecem com os preços e o consumo da data; consulte a página de preços para estimativas novas.

Tokens, custos e observabilidade

Os tokens de raciocínio fazem parte dos tokens de conclusão. O campo completion_tokens_details.reasoning_tokens detalha quantos tokens foram usados no raciocínio; ele não deve ser somado novamente a completion_tokens.

Registre, no mínimo, o ID do modelo, modo, esforço, finish_reason, latência, tokens de entrada, cache hit, cache miss, tokens de conclusão e tokens de raciocínio. Não inclua API keys, credenciais ou conteúdo pessoal desnecessário nos logs. Consulte a explicação oficial de tokens e uso da API DeepSeek.

Erros comuns no DeepSeek Thinking Mode

Thinking foi ativado sem intenção: o modo vem habilitado por padrão; envie thinking.type: "disabled".
Temperature não altera a resposta: esse parâmetro não tem efeito no Thinking Mode.
HTTP 400 ao usar tools: remova tool_choice, preserve reasoning_content e converta content: null para uma string vazia no histórico do assistant.
Resposta truncada: trate finish_reason: "length" como falha de conclusão.
O usuário recebe o raciocínio bruto: transmita content como resposta final e defina uma política explícita para qualquer outro campo.
Uso de developer role: use uma mensagem system; as notas de compatibilidade V4 indicam que o endpoint não aceita developer.
Uso de max_completion_tokens: a API DeepSeek documenta max_tokens.
Modelo inválido: para texto, use deepseek-v4-flash ou deepseek-v4-pro; para imagem, use deepseek-v4-flash-vision-exp. Consulte GET /models antes de depender de aliases antigos.

Para diferenciar formato inválido, autenticação, saldo, limite de requisições e falhas do servidor, consulte também a lista oficial de códigos de erro da DeepSeek.

Perguntas frequentes sobre o DeepSeek Thinking Mode

O Thinking Mode vem ativado por padrão?

Sim. Nos modelos V4 hospedados, thinking.type tem enabled como padrão. Ainda assim, definir enabled ou disabled explicitamente torna o comportamento do endpoint mais claro.

Qual é a diferença entre reasoning_content e content?

reasoning_content contém o conteúdo de raciocínio gerado antes da resposta. content contém a resposta final. Em turnos intermediários com tool calls, o primeiro precisa ser preservado no histórico conforme as regras oficiais.

Posso enviar tool_choice com Thinking?

Não no DeepSeek V4 Thinking. As notas oficiais de compatibilidade informam que o modo rejeita tool_choice. Envie a lista tools sem esse parâmetro.

Preciso guardar reasoning_content em toda conversa?

Não. Em um turno comum sem ferramentas, o raciocínio anterior não precisa participar da próxima solicitação. A exigência crítica aplica-se às mensagens intermediárias que realizaram tool calls: elas devem voltar completas em todos os pedidos seguintes daquele fluxo.

O Thinking Mode funciona com JSON Output?

Os modelos V4 hospedados listam suporte a Thinking e JSON Output. Mesmo assim, a aplicação deve solicitar JSON no prompt, verificar finish_reason, fazer o parse e validar campos e tipos antes de usar o resultado.

Os reasoning tokens são cobrados separadamente?

Eles fazem parte dos tokens gerados. reasoning_tokens é um detalhamento dentro de completion_tokens, não uma quantidade que deve ser adicionada novamente ao total.

DeepSeek R1 é o mesmo que Thinking Mode?

Não. DeepSeek R1 é uma família de modelo publicada anteriormente. Thinking Mode é o mecanismo usado pelos modelos V4 hospedados para alternar entre raciocínio e resposta direta. Da mesma forma, o alias legado deepseek-reasoner não representa V4 Pro.

Guias relacionados

Nota final: parâmetros, modelos, limites e regras de compatibilidade podem mudar. Antes de implantar uma integração em produção, valide a documentação oficial, consulte GET /models e execute testes controlados com a conta e o endpoint que serão usados pela aplicação.