Claude Code: erro "court" + invoke (chamada de ferramenta vaza)

Se você já rodou sessões longas no Claude Code, talvez tenha visto uma string estranha surgir de repente na sua tela:

court
<invoke name="Bash">
<parameter name="command">ssh host 'cp file file.bak ; sed -i ...'</parameter>
<parameter name="description">…descrição do comando…</parameter>
</invoke>

Your tool call was malformed and could not be parsed. Please retry.

Uma chamada de ferramenta (um comando) que deveria rodar nos bastidores vaza para o chat como texto cru — e nunca é executada. Na frente, aparece uma palavra sem sentido, court (ou call). É natural pensar "será que meu computador quebrou?" ou "configurei algo errado?". Mas a resposta curta é: não é o seu ambiente, nem o seu comando.

Trata-se de uma falha do lado do modelo, em que o Claude (especialmente a família Opus 4.8 / 4.7) corrompe as "tags de controle" de uma chamada de ferramenta no momento em que as gera. O repositório oficial da Anthropic tem muitas issues abertas sobre isso (#64108, #64150, #64690, #65705, #66153, #67295, #68354 e mais). Este artigo expõe o mecanismo, as causas, os equívocos comuns, as correções para usuário/desenvolvedor, como distingui-lo de erros parecidos e a situação oficial — com base na documentação da Anthropic e nas issues reais. A medida mais importante, logo de cara: quando o court aparecer, não insista naquela sessão — saia cedo para uma sessão nova (/clear). A razão está explicada abaixo.

1. O que realmente acontece — o token "court" e as tags invoke

O <invoke name="Bash"> e o <parameter name="command"> que você vê são "marcação de chamada de ferramenta" que você nunca deveria ver. Quando o Claude roda um comando ou edita um arquivo, ele gera essas tags estruturadas em estilo XML como tokens, e o Claude Code (o harness) as interpreta e de fato executa o comando. Normalmente o harness absorve as tags, elas nunca chegam à tela, e você só vê o resultado da ferramenta.

Desta vez, porém, o "token de controle de abertura" da chamada de ferramenta foi gerado quebrado, com a palavra sem relação court ou call surgindo na frente. O harness só reage a uma sintaxe estrita, então ele decide "isto não é uma chamada de ferramenta, é só texto" e despeja tudo direto na tela. O comando não roda, e você recebe "Your tool call was malformed and could not be parsed." Em alguns casos não há mensagem de erro nenhuma e ele simplesmente trava em silêncio (na issue #65705 a resposta voltou como stop_reason=end_turn sem nada para executar, então a conversa ficou pendurada).

A palavra court em si não tem significado. Mas também não é uma palavra totalmente aleatória e pontual — em vários relatos independentes, o vazamento aparece como court / call com uma consistência estranha. A issue #64690 analisa isso como "um token adjacente no vocabulário sendo selecionado no lugar da tag correta." Em outras palavras, é melhor entender o court como uma assinatura que ajuda você a reconhecer esse bug.

2. Contexto: um agente também "gera" suas chamadas de ferramenta

Por que uma "tag de controle" pode quebrar, afinal? A chave é que para um agente de IA, uma chamada de ferramenta é, no fim das contas, apenas geração de texto.

Quando você usa ferramentas com a API do Claude, o formato que você vê como desenvolvedor é JSON (um bloco tool_use). Internamente, porém, o modelo segue um system prompt oculto que a Anthropic injeta automaticamente e gera as tags envoltórias <function_calls>, <invoke> e <parameter> como um fluxo de tokens. A camada da API então interpreta isso e converte em um bloco tool_use JSON limpo (conforme a documentação oficial de tool use). Toda "chamada de ferramenta" em MCP e agentes de IA se apoia nesse mecanismo.

O que importa aqui é que o parser do harness é "fail-closed" (ele erra para o lado seguro). Se uma tag diferir da forma esperada em apenas um token, o harness não adivinha nem executa — ele rejeita imediatamente como malformada. Esse é o design de harness correto: "consertar prestativamente" um comando ambíguo e rodá-lo seria muito mais perigoso. Então todo esse fenômeno é um caso de "quebrou → foi rejeitado → não rodou" — ou seja, falhou de forma segura.

3. Por que acontece — duas causas-raiz e gatilhos

Consolidando as issues reais, a causa se divide em "(1) corrupção no momento da geração" e na "(2) reação em cadeia por autoenvenenamento" que a torna desagradável.

4. Três equívocos comuns, corrigidos

A informação sobre esse fenômeno se embaralha facilmente. Para reagir corretamente, aqui estão três equívocos comuns esclarecidos.

O segundo é o que mais importa. Relatos de incidentes costumam dizer "se recuperou na retentativa, então sem problema" — mas isso só vale para o caso "leve" antes de a cadeia começar. A essência desse bug é que uma vez que ele entra em modo de cadeia, nenhuma quantidade de retentativas dentro daquela sessão vai consertá-lo.

5. Resolva agora (para usuários do Claude Code)

A reação depende de "você ainda está leve ou a cadeia já começou?" Em ordem de prioridade:

Dica: se você habitualmente salva o estado em git ou numa nota de passagem em .md, mudar para uma sessão nova a qualquer momento não custa nada. Quanto mais você roda sessões autônomas longas, mais esse hábito compensa (e ele se conecta diretamente à gestão da sua janela de contexto).

6. Para desenvolvedores: previna via API/SDK

Se você constrói seu próprio agente sobre a API / SDK do Claude, pode adicionar as defesas a seguir no seu harness. A lógica de detecção proposta na issue #65705 é prática.

// Inspecione o turno do assistente recebido antes de executar
const text = assistantText(resp);
const looksLeaked =
  /<invoke\s+name=/.test(text) ||
  /function_calls/.test(text) ||
  /\bcourt\s*<invoke/.test(text);

// 1) Marcação acima presente mas SEM bloco tool_use estruturado → chamada quebrada
if (looksLeaked && !hasToolUseBlock(resp)) {
  // 2) Não mostre; registre em log. NÃO mantenha o bloco quebrado no histórico (previne autoenvenenamento)
  // 3) Empurre para "emitir como tool_use estruturado, não texto" e tente de novo automaticamente
  return retryWithNudge(messages);
}

// Rejeite um tool_use incompleto causado por truncamento
if (resp.stop_reason === 'max_tokens' && lastBlock(resp)?.type === 'tool_use') {
  return retryWith({ max_tokens: higher }); // não execute
}

Quatro princípios. (1) Sempre verifique o stop_reason (um end_turn sem nenhuma ferramenta de fato rodando = detecte a trava silenciosa). (2) Antes de executar, verifique se o texto não contém <invoke name= ou function_calls; se contiver, tente de novo em vez de executar. (3) Não mantenha o bloco quebrado no histórico da conversa (mantê-lo faz a próxima geração imitá-lo — autoenvenenamento / #62344). (4) Mantenha os argumentos de ferramenta curtos e divida saídas longas (evite a variante de payload longo na #49747). Mesmo ao usar um harness oficial como o Claude Agent SDK, vale entender como os loops de longa duração se comportam.

7. Diferenciando de erros parecidos

Existem vários erros de "a ferramenta não roda", e eles precisam de correções diferentes. Distinga estes quatro para não confundi-los.

O eixo para diferenciá-los é simples. Se você vê um "embaralhamento court / call + XML cru," é este bug. Um erro de assinatura 400 é o erro de bloco de thinking. Um corte limpo é só o limite de saída. Apenas no Bedrock ou via LangChain aponta para a camada de integração. Para outros erros comuns do Claude Code, veja a compilação de erros.

8. Situação oficial

Em junho de 2026, não há correção oficial confirmada (entrada de changelog) afirmando que esse fenômeno foi resolvido. Rastreando as notas de versão até o Claude Code mais recente (a linha 2.1.183), não há entrada que trate da corrupção de serialização de chamada de ferramenta, e muitas das issues relacionadas permanecem abertas, ou foram registradas como "duplicate / stale." Então toda correção neste artigo é uma solução de contorno enquanto se aguarda uma correção oficial, e não dá para afirmar que "atualizar para a versão mais recente resolve" (atualizar é recomendado, mas não é cura garantida).

Dito isso, o design fail-closed do harness de "rejeitar uma chamada quebrada em vez de executá-la por adivinhação" está, em si, correto. O que precisa de conserto é a estabilidade da geração do modelo — não afrouxar o parser para "consertar e rodar mesmo assim," o que convidaria o risco sério de rodar o comando errado. A melhor coisa que nós, usuários, podemos fazer é operar para evitar a cadeia e reportar reproduções nas issues oficiais com seu ambiente e logs (mais relatos elevam a prioridade e aceleram a correção).

9. Checklist de prevenção

Usuários do Claude Code: (1) Quando court/call aparecer, tente de novo no máximo duas vezes; se persistir, faça /clear / sessão nova imediatamente. (2) Evite sessões muito longas / de vários dias; salve o trabalho em git/notas nos pontos de parada. (3) Não empilhe múltiplas chamadas de ferramenta numa única mensagem. (4) Lembre-se de que o /compact não é uma panaceia (pode recorrer logo depois). (5) Mantenha a CLI atualizada e reporte reproduções nas issues oficiais.

Desenvolvedores de API/SDK: (1) Sempre verifique o stop_reason. (2) Detecte <invoke name= / function_calls vazando no texto e tente de novo. (3) Não mantenha chamadas quebradas no histórico (previna o autoenvenenamento). (4) Mantenha os argumentos de ferramenta curtos; divida saídas longas. (5) Nunca execute um tool_use incompleto vindo de um corte por max_tokens — tente de novo em vez disso.

Resumo

No Claude Code, "court / call + uma tag <invoke> crua exibida, com a ferramenta não executando" é uma falha do lado do modelo, em que o Claude (a família Opus 4.8 / 4.7) gera o token de controle de uma chamada de ferramenta de forma quebrada. O harness o rejeita em modo fail-closed, então não há risco de um comando errado rodar (falhou de forma segura). A parte realmente desagradável é que uma vez que o bloco quebrado fica no histórico, o modelo o imita e "encadeia." Por isso, "tentar de novo resolve" só vale enquanto está leve, e a regra passa a ser "errou duas vezes, saia para uma sessão nova."

A causa tem duas camadas: (1) corrupção na geração do token de controle + (2) encadeamento via autoenvenenamento. Os gatilhos incluem sessões longas / de vários dias, contexto pesado, o estado pós-/compact, múltiplas ferramentas concorrentes, 3+ servidores MCP e argumentos de ferramenta longos. Como nenhuma correção oficial foi lançada até junho de 2026, todo remédio é uma solução de contorno. Usuários devem "preferir uma sessão nova + salvar o estado com frequência"; desenvolvedores devem "verificar o stop_reason, tentar de novo ao detectar vazamento, nunca manter histórico quebrado e encurtar os argumentos." Ler o erro 400 de bloco de thinking, a compilação de erros do Claude Code e MCP junto com este texto vai deixar você muito mais resiliente a problemas de chamada de ferramenta.

FAQ

Q. O "court" ou a tag invoke na minha tela são causados por um erro no meu comando ou nas configurações?
A. Não — quase certamente não. Esta é uma falha conhecida do lado do modelo, em que o Claude gera tags de chamada de ferramenta de forma quebrada, com várias issues registradas no repositório oficial da Anthropic (#64108, #65705, #66153 e mais). Não é um erro no seu ambiente, comando ou configurações. Trate court/call como uma "assinatura" do bug.

Q. Um comando errado poderia rodar e danificar meu servidor ou arquivos quando isso acontece?
A. Não. Uma chamada de ferramenta quebrada é julgada "malformada" e rejeitada sem executar (design fail-closed). Tudo o que acontece é que o turno é desperdiçado e o texto de controle fica visível; não há efeito sobre seus dados ou o estado do servidor. Ele é projetado para falhar de forma segura.

Q. Ouvi dizer "basta tentar de novo que se resolve sozinho." Isso é verdade?
A. Só quando está leve. Numa primeira ocorrência pontual, um empurrãozinho para "continuar" muitas vezes faz o modelo reemitir corretamente. Mas uma vez que o bloco quebrado fica no histórico da conversa, o modelo o usa como template e repete a mesma corrupção (autoenvenenamento). A partir daí, tentar de novo na mesma sessão tem efeito reverso. Se falhar duas vezes seguidas, pare de insistir e mude para uma sessão nova (/clear).

Q. O /compact vai resolver?
A. Não de forma confiável. Compactar o contexto às vezes ajuda, mas na issue #67295 ele recorreu na primeiríssima chamada de ferramenta logo após o /compact. A medida mais confiável não é o /compact e sim uma sessão nova (/clear) que reseta totalmente o histórico. Salve seu estado de trabalho em git ou notas antes de mudar.

Q. Atualizar o Claude Code para a versão mais recente vai resolver?
A. Não dá para afirmar que "resolve." Em junho de 2026 não há entrada oficial de changelog confirmando uma correção, e muitas issues relacionadas permanecem abertas ou duplicadas. Atualizar é recomendado como higiene, mas não é uma cura mágica. Por ora, a melhor abordagem é operar para evitar a cadeia (errou duas vezes → sessão nova) e reportar reproduções nas issues oficiais.