MensagensDesenvolvendo com o Claude

Motivos de parada e fallback

O campo stop_reason, o que cada valor significa e onde lidar com recusas e fallback.

Quando você faz uma requisição à Messages API, a resposta do Claude inclui um campo stop_reason que indica por que o modelo parou de gerar sua resposta. Entender esses valores é crucial para construir aplicações robustas que lidam adequadamente com diferentes tipos de resposta.

Para detalhes sobre stop_reason na resposta da API, consulte a referência da Messages API.

O campo stop_reason

O campo stop_reason faz parte de toda resposta bem-sucedida da Messages API. Diferentemente de erros, que indicam falhas no processamento da sua requisição, stop_reason informa por que o Claude concluiu a geração da resposta.

Example response

{
  "id": "msg_01234",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Here's the answer to your question..."
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 100,
    "output_tokens": 50
  }
}

Valores de stop reason

end_turn

O motivo de parada mais comum. Indica que o Claude finalizou sua resposta naturalmente.

Python

from anthropic import Anthropic

client = Anthropic()
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}],
)
if response.stop_reason == "end_turn":
    # Processar a resposta completa
    print(response.content[0].text)

Respostas vazias com end_turn

Às vezes, o Claude retorna uma resposta vazia (exatamente 2-3 tokens sem conteúdo) com stop_reason: "end_turn". Isso normalmente acontece quando o Claude interpreta que o turno do assistente está completo, particularmente após resultados de ferramentas.

Causas comuns:

Adicionar blocos de texto imediatamente após resultados de ferramentas (o Claude aprende a esperar que o usuário sempre insira texto após resultados de ferramentas, então ele encerra seu turno para seguir o padrão)
Enviar a resposta concluída do Claude de volta sem adicionar nada (o Claude já decidiu que terminou, então permanecerá assim)

Como prevenir respostas vazias:

# INCORRETO: Adicionar texto imediatamente após tool_result
messages = [
    {"role": "user", "content": "Calculate the sum of 1234 and 5678"},
    {
        "role": "assistant",
        "content": [
            {
                "type": "tool_use",
                "id": "toolu_123",
                "name": "calculator",
                "input": {"operation": "add", "a": 1234, "b": 5678},
            }
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "tool_result", "tool_use_id": "toolu_123", "content": "6912"},
            {
                "type": "text",
                "text": "Here's the result",  # Don't add text after tool_result
            },
        ],
    },
]

# CORRETO: Envie os resultados da ferramenta diretamente, sem texto adicional
messages = [
    {"role": "user", "content": "Calculate the sum of 1234 and 5678"},
    {
        "role": "assistant",
        "content": [
            {
                "type": "tool_use",
                "id": "toolu_123",
                "name": "calculator",
                "input": {"operation": "add", "a": 1234, "b": 5678},
            }
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "tool_result", "tool_use_id": "toolu_123", "content": "6912"}
        ],
    },  # Just the tool_result, no additional text
]


# Se você ainda receber respostas vazias após corrigir a estrutura da mensagem:
def handle_empty_response(client, messages):
    response = client.messages.create(
        model="claude-opus-4-8", max_tokens=1024, messages=messages
    )

    # Verifique se a resposta está vazia
    if response.stop_reason == "end_turn" and not response.content:
        # INCORRETO: Não tente novamente apenas com a resposta vazia
        # Isso não funcionará porque o Claude já decidiu que terminou

        # CORRETO: Adicione um prompt de continuação em uma NOVA mensagem de usuário
        messages.append({"role": "user", "content": "Please continue"})

        response = client.messages.create(
            model="claude-opus-4-8", max_tokens=1024, messages=messages
        )

    return response

Melhores práticas:

Nunca adicione blocos de texto imediatamente após resultados de ferramentas - Isso ensina o Claude a esperar input do usuário após cada uso de ferramentas
Não tente novamente respostas vazias sem modificação - Simplesmente enviar a resposta vazia de volta não ajudará
Use prompts de continuação como último recurso - Apenas se essas correções não resolverem o problema

max_tokens

O Claude parou porque atingiu o limite de max_tokens especificado na sua requisição.

Python

# Requisição com tokens limitados
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=10,
    messages=[{"role": "user", "content": "Explain quantum physics"}],
)

if response.stop_reason == "max_tokens":
    # A resposta foi truncada
    print("Response was cut off at token limit")
    # Considere fazer outra requisição para continuar

Blocos de tool use incompletos

Se a resposta do Claude for cortada por atingir o limite de max_tokens, e a resposta truncada contiver um bloco de tool use incompleto, você precisará tentar novamente a requisição com um valor de max_tokens mais alto para obter o tool use completo.

# Verificar se a resposta foi truncada durante o uso de ferramentas
if response.stop_reason == "max_tokens":
    # Verificar se o último bloco de conteúdo é um tool_use incompleto
    last_block = response.content[-1]
    if last_block.type == "tool_use":
        # Enviar a requisição com max_tokens maior
        response = client.messages.create(
            model="claude-opus-4-8",
            max_tokens=4096,  # Increased limit
            messages=messages,
            tools=tools,
        )

stop_sequence

O Claude encontrou uma das suas sequências de parada personalizadas.

Python

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    stop_sequences=["END", "STOP"],
    messages=[{"role": "user", "content": "Generate text until you say END"}],
)

if response.stop_reason == "stop_sequence":
    print(f"Stopped at sequence: {response.stop_sequence}")

tool_use

O Claude está chamando uma ferramenta e espera que você a execute.

Para a maioria das implementações de uso de ferramentas, use o tool runner, que lida automaticamente com a execução de ferramentas, formatação de resultados e gerenciamento de conversas.

Python

from anthropic import Anthropic

client = Anthropic()
weather_tool = {
    "name": "get_weather",
    "description": "Get the current weather in a given location",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City and state"},
        },
        "required": ["location"],
    },
}


def execute_tool(name, tool_input):
    """Execute a tool and return the result."""
    return f"Weather in {tool_input.get('location', 'unknown')}: 72°F"


response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=[weather_tool],
    messages=[{"role": "user", "content": "What's the weather?"}],
)

if response.stop_reason == "tool_use":
    # Extrair e executar a ferramenta
    for content in response.content:
        if content.type == "tool_use":
            result = execute_tool(content.name, content.input)
            # Retornar o resultado ao Claude para a resposta final

pause_turn

Retornado quando o loop de amostragem do lado do servidor atinge seu limite de iterações ao executar ferramentas de servidor como busca na web ou web fetch. O limite padrão é de 10 iterações por requisição.

Quando isso acontece, a resposta pode conter um bloco server_tool_use sem um server_tool_result correspondente. Para permitir que o Claude termine o processamento, continue a conversa enviando a resposta de volta como está.

Python

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    tools=[{"type": "web_search_20250305", "name": "web_search"}],
    messages=[{"role": "user", "content": "Search for latest AI news"}],
)

if response.stop_reason == "pause_turn":
    # Continue a conversa enviando a resposta de volta
    messages = [
        {"role": "user", "content": original_query},
        {"role": "assistant", "content": response.content},
    ]
    continuation = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=1024,
        messages=messages,
        tools=[{"type": "web_search_20250305", "name": "web_search"}],
    )

Sua aplicação deve lidar com pause_turn em qualquer loop de agente que use ferramentas de servidor. Simplesmente adicione a resposta do assistente ao seu array de mensagens e faça outra requisição à API para permitir que o Claude continue.

refusal

O Claude se recusou a gerar uma resposta. No Claude Fable 5, classificadores de segurança retornam esse motivo de parada como uma resposta HTTP 200 normal, não como um erro.

Python

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[{"role": "user", "content": "[Unsafe request]"}],
)

if response.stop_reason == "refusal":
    # O Claude se recusou a responder
    print("Claude was unable to process this request")
    # Considere reformular ou modificar a solicitação

Se você encontrar motivos de parada refusal com frequência ao usar o Claude Sonnet 4.5 ou Opus 4.1 (descontinuado), você pode tentar atualizar suas chamadas de API para usar o Haiku 4.5 (claude-haiku-4-5-20251001), que tem restrições de uso diferentes. Saiba mais sobre como entender os filtros de segurança da API do Sonnet 4.5.

Em uma recusa, o objeto stop_details identifica a categoria de política que a acionou. As categorias e o formato completo da resposta de recusa são abordados em Recusas e fallback. stop_details é null para todos os motivos de parada diferentes de refusal.

Uma requisição recusada no Claude Fable 5 geralmente pode ser atendida tentando novamente em outro modelo Claude, e Recusas e fallback mostra como configurar essa nova tentativa, no lado do servidor ou no seu cliente. Crédito de fallback aborda como evitar pagar o custo de cache de prompt duas vezes quando você mesmo constrói a nova tentativa.

model_context_window_exceeded

O Claude parou porque atingiu o limite da "context window" (janela de contexto) do modelo. Isso permite que você solicite o máximo de tokens possível sem saber o tamanho exato da entrada.

Python

# Requisição com o máximo de tokens para obter o máximo possível
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=20000,  # Python SDK requires streaming for max_tokens above ~21k (Opus 4.8 supports 128k with streaming)
    messages=[
        {"role": "user", "content": "Large input that uses most of context window..."}
    ],
)

if response.stop_reason == "model_context_window_exceeded":
    # A resposta atingiu o limite da janela de contexto antes de max_tokens
    print("Response reached model's context window limit")
    # A resposta ainda é válida, mas foi limitada pela janela de contexto

Esse motivo de parada está disponível por padrão no Sonnet 4.5 e em modelos mais recentes. Para modelos anteriores, use o cabeçalho beta model-context-window-exceeded-2025-08-26 para habilitar esse comportamento.

Melhores práticas para lidar com motivos de parada

1. Sempre verifique stop_reason

Crie o hábito de verificar o stop_reason na sua lógica de tratamento de respostas:

def handle_response(response):
    if response.stop_reason == "tool_use":
        return handle_tool_use(response)
    elif response.stop_reason == "max_tokens":
        return handle_truncation(response)
    elif response.stop_reason == "model_context_window_exceeded":
        return handle_context_limit(response)
    elif response.stop_reason == "pause_turn":
        return handle_pause(response)
    elif response.stop_reason == "refusal":
        return handle_refusal(response)
    else:
        # Trata end_turn e outros casos
        return response.content[0].text

2. Lide com respostas truncadas de forma elegante

Quando uma resposta é truncada devido a limites de tokens ou à janela de contexto:

def handle_truncated_response(response):
    if response.stop_reason in ["max_tokens", "model_context_window_exceeded"]:
        # Opção 1: Avisar o usuário sobre o limite específico
        if response.stop_reason == "max_tokens":
            message = "[Response truncated due to max_tokens limit]"
        else:
            message = "[Response truncated due to context window limit]"
        return f"{response.content[0].text}\n\n{message}"

        # Opção 2: Continuar a geração
        messages = [
            {"role": "user", "content": original_prompt},
            {"role": "assistant", "content": response.content[0].text},
        ]
        continuation = client.messages.create(
            model="claude-opus-4-8",
            max_tokens=1024,
            messages=messages + [{"role": "user", "content": "Please continue"}],
        )
        return response.content[0].text + continuation.content[0].text

3. Implemente lógica de nova tentativa para pause_turn

Ao usar ferramentas de servidor, a API pode retornar pause_turn se o loop de amostragem do lado do servidor atingir seu limite de iterações (padrão 10). Lide com isso continuando a conversa:

def handle_server_tool_conversation(client, user_query, tools, max_continuations=5):
    """
    Handle server tool conversations that may require multiple continuations.

    The server runs a sampling loop when executing server tools. If the loop
    reaches its iteration limit, the API returns pause_turn. Continue the
    conversation by sending the response back to let Claude finish.
    """
    messages = [{"role": "user", "content": user_query}]

    for _ in range(max_continuations):
        response = client.messages.create(
            model="claude-opus-4-8", max_tokens=1024, messages=messages, tools=tools
        )

        if response.stop_reason != "pause_turn":
            # Claude terminou o processamento - retorne a resposta final
            return response

        # pause_turn: substitua a lista completa de mensagens para manter a alternância de papéis
        messages = [
            {"role": "user", "content": user_query},
            {"role": "assistant", "content": response.content},
        ]

    # Atingiu o máximo de continuações - retorne a última resposta
    return response

Motivos de parada vs. erros

É importante distinguir entre valores de stop_reason e erros reais:

Motivos de parada (respostas bem-sucedidas)

Fazem parte do corpo da resposta
Indicam por que a geração parou normalmente
A resposta contém conteúdo válido

Erros (requisições com falha)

Códigos de status HTTP 4xx ou 5xx
Indicam falhas no processamento da requisição
A resposta contém detalhes do erro

Python

import anthropic
from anthropic import Anthropic

client = Anthropic()

try:
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello!"}],
    )

    # Trata resposta bem-sucedida com stop_reason
    if response.stop_reason == "max_tokens":
        print("Response was truncated")

except anthropic.APIStatusError as e:
    # Trata erros reais
    if e.status_code == 429:
        print("Rate limit exceeded")
    elif e.status_code == 500:
        print("Server error")

Considerações sobre streaming

Ao usar streaming, stop_reason é:

null no evento inicial message_start
Fornecido no evento message_delta
Não fornecido em nenhum outro evento

Python

from anthropic import Anthropic

client = Anthropic()

with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}],
) as stream:
    for event in stream:
        if event.type == "message_delta":
            stop_reason = event.delta.stop_reason
            if stop_reason:
                print(f"Stream ended with: {stop_reason}")

Padrões comuns

Lidando com fluxos de trabalho de uso de ferramentas

Mais simples com o tool runner: O exemplo a seguir mostra o tratamento manual de ferramentas. Para a maioria dos casos de uso, o tool runner lida automaticamente com a execução de ferramentas com muito menos código.

def complete_tool_workflow(client, user_query, tools):
    messages = [{"role": "user", "content": user_query}]

    while True:
        response = client.messages.create(
            model="claude-opus-4-8", max_tokens=1024, messages=messages, tools=tools
        )

        if response.stop_reason == "tool_use":
            # Executar ferramentas e continuar
            tool_results = execute_tools(response.content)
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": tool_results})
        else:
            # Resposta final
            return response

Garantindo respostas completas

def get_complete_response(client, prompt, max_attempts=3):
    messages = [{"role": "user", "content": prompt}]
    full_response = ""

    for _ in range(max_attempts):
        response = client.messages.create(
            model="claude-opus-4-8", messages=messages, max_tokens=4096
        )

        full_response += response.content[0].text

        if response.stop_reason != "max_tokens":
            break

        # Continuar de onde parou
        messages = [
            {"role": "user", "content": prompt},
            {"role": "assistant", "content": full_response},
            {"role": "user", "content": "Please continue from where you left off."},
        ]

    return full_response

Obtendo o máximo de tokens sem saber o tamanho da entrada

Com o motivo de parada model_context_window_exceeded, você pode solicitar o máximo de tokens possível sem calcular o tamanho da entrada:

def get_max_possible_tokens(client, prompt):
    """
    Get as many tokens as possible within the model's context window
    without needing to calculate input token count
    """
    response = client.messages.create(
        model="claude-opus-4-8",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=20000,  # Python SDK requires streaming for max_tokens above ~21k
    )

    if response.stop_reason == "model_context_window_exceeded":
        # Obteve o máximo de tokens possível dado o tamanho da entrada
        print(
            f"Generated {response.usage.output_tokens} tokens (context limit reached)"
        )
    elif response.stop_reason == "max_tokens":
        # Obteve exatamente os tokens solicitados
        print(f"Generated {response.usage.output_tokens} tokens (max_tokens reached)")
    else:
        # Conclusão natural
        print(f"Generated {response.usage.output_tokens} tokens (natural completion)")

    return response.content[0].text

Ao lidar adequadamente com os valores de stop_reason, você pode construir aplicações mais robustas que lidam de forma elegante com diferentes cenários de resposta e fornecem melhores experiências ao usuário.

Was this page helpful?

MensagensDesenvolvendo com o Claude

Motivos de parada e fallback

O campo stop_reason, o que cada valor significa e onde lidar com recusas e fallback.

Para detalhes sobre stop_reason na resposta da API, consulte a referência da Messages API.

O campo stop_reason

Example response

{
  "id": "msg_01234",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Here's the answer to your question..."
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 100,
    "output_tokens": 50
  }
}

Valores de stop reason

end_turn

O motivo de parada mais comum. Indica que o Claude finalizou sua resposta naturalmente.

Python

from anthropic import Anthropic

client = Anthropic()
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}],
)
if response.stop_reason == "end_turn":
    # Processar a resposta completa
    print(response.content[0].text)

Respostas vazias com end_turn

Causas comuns:

Adicionar blocos de texto imediatamente após resultados de ferramentas (o Claude aprende a esperar que o usuário sempre insira texto após resultados de ferramentas, então ele encerra seu turno para seguir o padrão)
Enviar a resposta concluída do Claude de volta sem adicionar nada (o Claude já decidiu que terminou, então permanecerá assim)

Como prevenir respostas vazias:

# INCORRETO: Adicionar texto imediatamente após tool_result
messages = [
    {"role": "user", "content": "Calculate the sum of 1234 and 5678"},
    {
        "role": "assistant",
        "content": [
            {
                "type": "tool_use",
                "id": "toolu_123",
                "name": "calculator",
                "input": {"operation": "add", "a": 1234, "b": 5678},
            }
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "tool_result", "tool_use_id": "toolu_123", "content": "6912"},
            {
                "type": "text",
                "text": "Here's the result",  # Don't add text after tool_result
            },
        ],
    },
]

# CORRETO: Envie os resultados da ferramenta diretamente, sem texto adicional
messages = [
    {"role": "user", "content": "Calculate the sum of 1234 and 5678"},
    {
        "role": "assistant",
        "content": [
            {
                "type": "tool_use",
                "id": "toolu_123",
                "name": "calculator",
                "input": {"operation": "add", "a": 1234, "b": 5678},
            }
        ],
    },
    {
        "role": "user",
        "content": [
            {"type": "tool_result", "tool_use_id": "toolu_123", "content": "6912"}
        ],
    },  # Just the tool_result, no additional text
]


# Se você ainda receber respostas vazias após corrigir a estrutura da mensagem:
def handle_empty_response(client, messages):
    response = client.messages.create(
        model="claude-opus-4-8", max_tokens=1024, messages=messages
    )

    # Verifique se a resposta está vazia
    if response.stop_reason == "end_turn" and not response.content:
        # INCORRETO: Não tente novamente apenas com a resposta vazia
        # Isso não funcionará porque o Claude já decidiu que terminou

        # CORRETO: Adicione um prompt de continuação em uma NOVA mensagem de usuário
        messages.append({"role": "user", "content": "Please continue"})

        response = client.messages.create(
            model="claude-opus-4-8", max_tokens=1024, messages=messages
        )

    return response

Melhores práticas:

Nunca adicione blocos de texto imediatamente após resultados de ferramentas - Isso ensina o Claude a esperar input do usuário após cada uso de ferramentas
Não tente novamente respostas vazias sem modificação - Simplesmente enviar a resposta vazia de volta não ajudará
Use prompts de continuação como último recurso - Apenas se essas correções não resolverem o problema

max_tokens

O Claude parou porque atingiu o limite de max_tokens especificado na sua requisição.

Python

# Requisição com tokens limitados
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=10,
    messages=[{"role": "user", "content": "Explain quantum physics"}],
)

if response.stop_reason == "max_tokens":
    # A resposta foi truncada
    print("Response was cut off at token limit")
    # Considere fazer outra requisição para continuar

Blocos de tool use incompletos

# Verificar se a resposta foi truncada durante o uso de ferramentas
if response.stop_reason == "max_tokens":
    # Verificar se o último bloco de conteúdo é um tool_use incompleto
    last_block = response.content[-1]
    if last_block.type == "tool_use":
        # Enviar a requisição com max_tokens maior
        response = client.messages.create(
            model="claude-opus-4-8",
            max_tokens=4096,  # Increased limit
            messages=messages,
            tools=tools,
        )

stop_sequence

O Claude encontrou uma das suas sequências de parada personalizadas.

Python

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    stop_sequences=["END", "STOP"],
    messages=[{"role": "user", "content": "Generate text until you say END"}],
)

if response.stop_reason == "stop_sequence":
    print(f"Stopped at sequence: {response.stop_sequence}")

tool_use

O Claude está chamando uma ferramenta e espera que você a execute.

Para a maioria das implementações de uso de ferramentas, use o tool runner, que lida automaticamente com a execução de ferramentas, formatação de resultados e gerenciamento de conversas.

Python

from anthropic import Anthropic

client = Anthropic()
weather_tool = {
    "name": "get_weather",
    "description": "Get the current weather in a given location",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City and state"},
        },
        "required": ["location"],
    },
}


def execute_tool(name, tool_input):
    """Execute a tool and return the result."""
    return f"Weather in {tool_input.get('location', 'unknown')}: 72°F"


response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=[weather_tool],
    messages=[{"role": "user", "content": "What's the weather?"}],
)

if response.stop_reason == "tool_use":
    # Extrair e executar a ferramenta
    for content in response.content:
        if content.type == "tool_use":
            result = execute_tool(content.name, content.input)
            # Retornar o resultado ao Claude para a resposta final

pause_turn

Python

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    tools=[{"type": "web_search_20250305", "name": "web_search"}],
    messages=[{"role": "user", "content": "Search for latest AI news"}],
)

if response.stop_reason == "pause_turn":
    # Continue a conversa enviando a resposta de volta
    messages = [
        {"role": "user", "content": original_query},
        {"role": "assistant", "content": response.content},
    ]
    continuation = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=1024,
        messages=messages,
        tools=[{"type": "web_search_20250305", "name": "web_search"}],
    )

refusal

O Claude se recusou a gerar uma resposta. No Claude Fable 5, classificadores de segurança retornam esse motivo de parada como uma resposta HTTP 200 normal, não como um erro.

Python

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[{"role": "user", "content": "[Unsafe request]"}],
)

if response.stop_reason == "refusal":
    # O Claude se recusou a responder
    print("Claude was unable to process this request")
    # Considere reformular ou modificar a solicitação

model_context_window_exceeded

O Claude parou porque atingiu o limite da "context window" (janela de contexto) do modelo. Isso permite que você solicite o máximo de tokens possível sem saber o tamanho exato da entrada.

Python

# Requisição com o máximo de tokens para obter o máximo possível
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=20000,  # Python SDK requires streaming for max_tokens above ~21k (Opus 4.8 supports 128k with streaming)
    messages=[
        {"role": "user", "content": "Large input that uses most of context window..."}
    ],
)

if response.stop_reason == "model_context_window_exceeded":
    # A resposta atingiu o limite da janela de contexto antes de max_tokens
    print("Response reached model's context window limit")
    # A resposta ainda é válida, mas foi limitada pela janela de contexto

Melhores práticas para lidar com motivos de parada

1. Sempre verifique stop_reason

Crie o hábito de verificar o stop_reason na sua lógica de tratamento de respostas:

def handle_response(response):
    if response.stop_reason == "tool_use":
        return handle_tool_use(response)
    elif response.stop_reason == "max_tokens":
        return handle_truncation(response)
    elif response.stop_reason == "model_context_window_exceeded":
        return handle_context_limit(response)
    elif response.stop_reason == "pause_turn":
        return handle_pause(response)
    elif response.stop_reason == "refusal":
        return handle_refusal(response)
    else:
        # Trata end_turn e outros casos
        return response.content[0].text

2. Lide com respostas truncadas de forma elegante

Quando uma resposta é truncada devido a limites de tokens ou à janela de contexto:

def handle_truncated_response(response):
    if response.stop_reason in ["max_tokens", "model_context_window_exceeded"]:
        # Opção 1: Avisar o usuário sobre o limite específico
        if response.stop_reason == "max_tokens":
            message = "[Response truncated due to max_tokens limit]"
        else:
            message = "[Response truncated due to context window limit]"
        return f"{response.content[0].text}\n\n{message}"

        # Opção 2: Continuar a geração
        messages = [
            {"role": "user", "content": original_prompt},
            {"role": "assistant", "content": response.content[0].text},
        ]
        continuation = client.messages.create(
            model="claude-opus-4-8",
            max_tokens=1024,
            messages=messages + [{"role": "user", "content": "Please continue"}],
        )
        return response.content[0].text + continuation.content[0].text

3. Implemente lógica de nova tentativa para pause_turn

Ao usar ferramentas de servidor, a API pode retornar pause_turn se o loop de amostragem do lado do servidor atingir seu limite de iterações (padrão 10). Lide com isso continuando a conversa:

def handle_server_tool_conversation(client, user_query, tools, max_continuations=5):
    """
    Handle server tool conversations that may require multiple continuations.

    The server runs a sampling loop when executing server tools. If the loop
    reaches its iteration limit, the API returns pause_turn. Continue the
    conversation by sending the response back to let Claude finish.
    """
    messages = [{"role": "user", "content": user_query}]

    for _ in range(max_continuations):
        response = client.messages.create(
            model="claude-opus-4-8", max_tokens=1024, messages=messages, tools=tools
        )

        if response.stop_reason != "pause_turn":
            # Claude terminou o processamento - retorne a resposta final
            return response

        # pause_turn: substitua a lista completa de mensagens para manter a alternância de papéis
        messages = [
            {"role": "user", "content": user_query},
            {"role": "assistant", "content": response.content},
        ]

    # Atingiu o máximo de continuações - retorne a última resposta
    return response

Motivos de parada vs. erros

É importante distinguir entre valores de stop_reason e erros reais:

Motivos de parada (respostas bem-sucedidas)

Fazem parte do corpo da resposta
Indicam por que a geração parou normalmente
A resposta contém conteúdo válido

Erros (requisições com falha)

Códigos de status HTTP 4xx ou 5xx
Indicam falhas no processamento da requisição
A resposta contém detalhes do erro

Python

import anthropic
from anthropic import Anthropic

client = Anthropic()

try:
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello!"}],
    )

    # Trata resposta bem-sucedida com stop_reason
    if response.stop_reason == "max_tokens":
        print("Response was truncated")

except anthropic.APIStatusError as e:
    # Trata erros reais
    if e.status_code == 429:
        print("Rate limit exceeded")
    elif e.status_code == 500:
        print("Server error")

Considerações sobre streaming

Ao usar streaming, stop_reason é:

null no evento inicial message_start
Fornecido no evento message_delta
Não fornecido em nenhum outro evento

Python

from anthropic import Anthropic

client = Anthropic()

with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}],
) as stream:
    for event in stream:
        if event.type == "message_delta":
            stop_reason = event.delta.stop_reason
            if stop_reason:
                print(f"Stream ended with: {stop_reason}")

Padrões comuns

Lidando com fluxos de trabalho de uso de ferramentas

def complete_tool_workflow(client, user_query, tools):
    messages = [{"role": "user", "content": user_query}]

    while True:
        response = client.messages.create(
            model="claude-opus-4-8", max_tokens=1024, messages=messages, tools=tools
        )

        if response.stop_reason == "tool_use":
            # Executar ferramentas e continuar
            tool_results = execute_tools(response.content)
            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": tool_results})
        else:
            # Resposta final
            return response

Garantindo respostas completas

def get_complete_response(client, prompt, max_attempts=3):
    messages = [{"role": "user", "content": prompt}]
    full_response = ""

    for _ in range(max_attempts):
        response = client.messages.create(
            model="claude-opus-4-8", messages=messages, max_tokens=4096
        )

        full_response += response.content[0].text

        if response.stop_reason != "max_tokens":
            break

        # Continuar de onde parou
        messages = [
            {"role": "user", "content": prompt},
            {"role": "assistant", "content": full_response},
            {"role": "user", "content": "Please continue from where you left off."},
        ]

    return full_response

Obtendo o máximo de tokens sem saber o tamanho da entrada

Com o motivo de parada model_context_window_exceeded, você pode solicitar o máximo de tokens possível sem calcular o tamanho da entrada:

def get_max_possible_tokens(client, prompt):
    """
    Get as many tokens as possible within the model's context window
    without needing to calculate input token count
    """
    response = client.messages.create(
        model="claude-opus-4-8",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=20000,  # Python SDK requires streaming for max_tokens above ~21k
    )

    if response.stop_reason == "model_context_window_exceeded":
        # Obteve o máximo de tokens possível dado o tamanho da entrada
        print(
            f"Generated {response.usage.output_tokens} tokens (context limit reached)"
        )
    elif response.stop_reason == "max_tokens":
        # Obteve exatamente os tokens solicitados
        print(f"Generated {response.usage.output_tokens} tokens (max_tokens reached)")
    else:
        # Conclusão natural
        print(f"Generated {response.usage.output_tokens} tokens (natural completion)")

    return response.content[0].text

Was this page helpful?