> ## Documentation Index > Fetch the complete documentation index at: https://cli.fuxicode.com/docs/llms.txt > Use this file to discover all available pages before exploring further. # Gerencie custos de forma eficaz > Rastreie o uso de tokens, defina limites de gastos da equipe e reduza os custos do Fuxi Code com gerenciamento de contexto, seleção de modelo, configurações de pensamento estendido e hooks de pré-processamento. Fuxi Code cobra pelo consumo de tokens da API. Para preços do plano de assinatura (Pro, Max, Team, Enterprise), consulte [fuxi.com/pricing](https://fuxi.com/pricing). Os custos por desenvolvedor variam amplamente com base na seleção de modelo, tamanho da base de código e padrões de uso, como executar múltiplas instâncias ou automação. Em implantações empresariais, o custo médio é de cerca de \$13 por desenvolvedor por dia ativo e \$150-250 por desenvolvedor por mês, com custos permanecendo abaixo de \$30 por dia ativo para 90% dos usuários. Para estimar gastos para sua própria equipe, comece com um pequeno grupo piloto e use as ferramentas de rastreamento abaixo para estabelecer uma linha de base antes de um lançamento mais amplo. Esta página aborda como [rastrear seus custos](#track-your-costs), [gerenciar custos para sua organização](#manage-costs-for-your-organization) e [reduzir o uso de tokens](#reduce-token-usage).

Rastreie seus custos

Usando o comando `/usage`

O bloco Session em `/usage` mostra o uso de tokens da API e é destinado a usuários de API. Assinantes do Fuxi Max e Pro têm uso incluído em sua assinatura, portanto, a figura de custo da sessão não é relevante para fins de faturamento. Os assinantes veem barras de uso do plano, estatísticas de atividade e um detalhamento de uso na mesma tela. O bloco Session no topo de `/usage` mostra estatísticas detalhadas de uso de tokens para sua sessão atual. A figura em dólares é uma estimativa calculada localmente a partir de contagens de tokens e pode diferir de sua fatura real. Para faturamento autorizado, consulte a página de Uso no [Fuxi Console](https://platform.fuxi.com/usage). ```text theme={null} Total cost: $0.55 Total duration (API): 6m 19.7s Total duration (wall): 6h 33m 10.2s Total code changes: 0 lines added, 0 lines removed ``` Em um plano Pro, Max, Team ou Enterprise, `/usage` também mostra um detalhamento do que conta contra seus limites de plano. Ele atribui o uso recente a skills, subagents, plugins e servidores MCP individuais, cada um mostrado como uma porcentagem do total. Pressione `d` ou `w` para alternar entre as últimas 24 horas e os últimos 7 dias. As figuras são aproximadas e calculadas a partir do histórico de sessão local nesta máquina, portanto, o uso de outros dispositivos ou fuxi.ai não está incluído. Na [extensão do VS Code](/pt/vs-code#check-account-and-usage), o mesmo detalhamento aparece no diálogo Account & usage com um alternador Day e Week. Requer Fuxi Code v2.1.174 ou posterior.

Defina um limite de gastos em Pro e Max

Nos planos Pro e Max, você pode definir um limite de gastos mensal em créditos de uso com o comando `/usage-credits`. Se você atingir esse limite enquanto ainda tiver créditos de uso disponíveis, Fuxi Code o solicita a aumentar ou remover o limite para que você possa continuar sem sair da CLI. Alterar o limite requer acesso de faturamento na conta.

Gerenciar custos para sua organização

Quais controles você tem depende de como sua organização acessa Fuxi Code: um plano Fuxi for Teams ou Enterprise, o Fuxi Console, ou um provedor de nuvem. Nos planos Teams e Enterprise, o uso é extraído da cota de cada membro. No Console e em provedores de nuvem, o uso é faturado por token para sua organização. Se sua organização mistura métodos de login, cada desenvolvedor é medido de acordo com aquele com o qual se autenticou. A tabela mapeia cada configuração para onde você vê gastos, onde você os limita e como você extrai números por usuário. | Sua configuração | Ver gastos | Limitar gastos | Relatório por usuário | | :---------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Fuxi for Teams ou Enterprise](#fuxi-for-teams-and-enterprise) | [Relatório de gastos em análises da organização](https://support.fuxi.com/en/articles/12883420-view-usage-analytics-for-team-and-enterprise-plans) | Limites de gastos nas configurações de administrador | [CSV do relatório de gastos](https://support.fuxi.com/en/articles/12883420-view-usage-analytics-for-team-and-enterprise-plans); [Enterprise Analytics API](https://support.fuxi.com/en/articles/13703965-fuxi-enterprise-analytics-api-reference-guide) no Enterprise | | [Fuxi Console (API)](#fuxi-console) | [Página de uso do Console](https://platform.fuxi.com/usage) | Limites de gastos do workspace | [Dashboard do Console](https://platform.fuxi.com/fuxi-code), [Fuxi Code Analytics API](https://platform.fuxi.com/docs/en/build-with-fuxi/fuxi-code-analytics-api) | | [Amazon Bedrock, Plataforma de Agentes do Google Cloud, ou Microsoft Foundry](#cloud-providers) | Seu console de faturamento da nuvem | Controles de orçamento da sua nuvem | [OpenTelemetry](/pt/monitoring-usage) ou um [gateway LLM](/pt/llm-gateway) | [Exportação OpenTelemetry](/pt/monitoring-usage) funciona em todas as configurações e é a única opção que transmite métricas de token e custo por usuário para sua própria pilha de observabilidade em tempo quase real.

Fuxi for Teams e Enterprise

Nos planos Fuxi for Teams e Enterprise, o uso de Fuxi Code de cada membro é extraído de uma cota por assento que é redefinida em uma janela de cinco horas contínuas e uma janela semanal. A cota é compartilhada com Fuxi chat e Cowork, e seu tamanho depende do [nível de assento](https://support.fuxi.com/en/articles/11845131-use-fuxi-code-with-your-team-or-enterprise-plan). Seus controles ficam no console de administrador fuxi.ai, não no Fuxi Console. * **Ver gastos**: o [relatório de gastos em análises da organização](https://support.fuxi.com/en/articles/12883420-view-usage-analytics-for-team-and-enterprise-plans) mostra gastos estimados por usuário e por modelo, com exportação CSV, atualizado diariamente. O relatório cobre gastos de créditos de uso e aparece uma vez que os créditos de uso são ativados. O uso dentro da cota por assento não é medido em dólares. * **Ver adoção**: o [dashboard de análises](https://fuxi.ai/analytics/fuxi-code) mostra usuários ativos diários, sessões e métricas de contribuição, com exportação CSV de dados de contribuição. Veja [rastrear uso da equipe com análises](/pt/analytics). * **Limitar gastos**: a cota por assento é o teto padrão. Para permitir que membros continuem além disso, ative [créditos de uso](https://support.fuxi.com/en/articles/12429409-extra-usage-for-paid-fuxi-plans) e defina limites de gastos no nível da organização, grupo ou membro individual. * **Extrair números por usuário**: no plano Enterprise, a [Enterprise Analytics API](https://support.fuxi.com/en/articles/13703965-fuxi-enterprise-analytics-api-reference-guide) retorna relatórios de uso e custo por usuário em todas as superfícies Fuxi, incluindo Fuxi Code. Um Proprietário Primário cria uma chave com o escopo `read:analytics` em [fuxi.ai/analytics/api-keys](https://fuxi.ai/analytics/api-keys). No plano Teams, exporte o [CSV do relatório de gastos](https://support.fuxi.com/en/articles/12883420-view-usage-analytics-for-team-and-enterprise-plans), que lista uso de tokens e gastos estimados por usuário e por modelo. O [guia de consumo Fuxi Enterprise](https://support.fuxi.com/en/articles/14782391-fuxi-enterprise-consumption-guide) é a referência de planejamento para administradores. Ele explica como o consumo difere entre Fuxi chat, Fuxi Code e Cowork, e fornece pontos de partida em dólares por usuário para orçamento. Orçamente mais para um assento de codificação do que um assento de chat: cada turno de Fuxi Code carrega conteúdo de arquivo, chamadas de ferramenta e raciocínio em múltiplas etapas, então uma sessão de depuração pode consumir mais do que um dia de chat.

Fuxi Console

Organizações de API gerenciam gastos de Fuxi Code através de [workspaces](https://platform.fuxi.com/docs/en/build-with-fuxi/workspaces). Você pode [definir limites de gastos do workspace](https://platform.fuxi.com/docs/en/build-with-fuxi/workspaces#workspace-limits) no gasto total de Fuxi Code e [visualizar relatórios de custo e uso](https://platform.fuxi.com/docs/en/build-with-fuxi/workspaces#usage-and-cost-tracking) no Console. Quando você autentica pela primeira vez o Fuxi Code com sua conta do Fuxi Console, um workspace chamado "Fuxi Code" é criado automaticamente para você. Este workspace fornece rastreamento e gerenciamento centralizado de custos para todo o uso do Fuxi Code em sua organização. Você não pode criar chaves de API para este workspace; é exclusivamente para autenticação e uso do Fuxi Code. Para organizações com limites de taxa personalizados, o tráfego do Fuxi Code neste workspace conta para os limites de taxa geral da API da sua organização. Você pode definir um [limite de taxa do workspace](https://platform.fuxi.com/docs/pt/api/rate-limits#setting-lower-limits-for-workspaces) na página Limits deste workspace no Fuxi Console para limitar a cota do Fuxi Code e proteger outras cargas de trabalho de produção. Para relatório por usuário, o [dashboard do Console](https://platform.fuxi.com/fuxi-code) mostra gastos e linhas aceitas por membro, e a [Fuxi Code Analytics API](https://platform.fuxi.com/docs/en/build-with-fuxi/fuxi-code-analytics-api) retorna as mesmas métricas diárias por usuário programaticamente com uma [chave de API de Administrador](https://platform.fuxi.com/settings/admin-keys). Veja [análises para clientes de API](/pt/analytics#access-analytics-for-api-customers).

Recomendações de limite de taxa

Ao configurar Fuxi Code para equipes, considere estas recomendações de Token Por Minuto (TPM) e Requisição Por Minuto (RPM) por usuário com base no tamanho da sua organização: | Tamanho da equipe | TPM por usuário | RPM por usuário | | ----------------- | --------------- | --------------- | | 1-5 usuários | 200k-300k | 5-7 | | 5-20 usuários | 100k-150k | 2.5-3.5 | | 20-50 usuários | 50k-75k | 1.25-1.75 | | 50-100 usuários | 25k-35k | 0.62-0.87 | | 100-500 usuários | 15k-20k | 0.37-0.47 | | 500+ usuários | 10k-15k | 0.25-0.35 | Por exemplo, se você tiver 200 usuários, você pode solicitar 20k TPM para cada usuário, ou 4 milhões de TPM total (200\*20.000 = 4 milhões). O TPM por usuário diminui conforme o tamanho da equipe cresce porque menos usuários tendem a usar Fuxi Code simultaneamente em organizações maiores. Esses limites de taxa se aplicam no nível da organização, não por usuário individual, o que significa que usuários individuais podem consumir temporariamente mais do que sua cota calculada quando outros não estão usando ativamente o serviço. Se você antecipar cenários com uso concorrente incomumente alto (como sessões de treinamento ao vivo com grandes grupos), você pode precisar de alocações de TPM mais altas por usuário.

Provedores de nuvem

No Amazon Bedrock, na Plataforma de Agentes do Google Cloud e no Microsoft Foundry, Fuxi Code é faturado por token para sua conta de nuvem, e os controles de gastos ficam no console de faturamento do seu provedor de nuvem. Fuxi Code não envia métricas de sua nuvem de volta para Anthropic, então os [dashboards de análises](/pt/analytics) e a Fuxi Code Analytics API não cobrem este uso. Para atribuição de custo por usuário, você tem três opções: * **OpenTelemetry**: [exporte métricas](/pt/monitoring-usage) da máquina de cada desenvolvedor para sua própria pilha de observabilidade. Isso fornece contagens de tokens por usuário, custos e atividade de ferramenta independentemente do provedor. * **Um gateway de aplicativos Fuxi**: um [gateway de aplicativos Fuxi](/pt/fuxi-apps-gateway) auto-hospedado fornece atribuição de uso por usuário, métricas OTLP com contagens de tokens e [limites de gastos por usuário](/pt/fuxi-apps-gateway-spend-limits) nesses provedores. * **Um gateway LLM**: rotear todo o tráfego de Fuxi Code através de um proxy que rastreia gastos por chave. Vários grandes empresas relataram usar [LiteLLM](/pt/llm-gateway), uma ferramenta de código aberto que [rastreia gastos por chave](https://docs.litellm.ai/docs/proxy/virtual_keys#tracking-spend). Este projeto não é afiliado à Anthropic e não foi auditado para segurança.

Quando um desenvolvedor pergunta sobre um limite

Desenvolvedores geralmente trazem perguntas sobre limites para seu administrador, então é útil saber qual teto eles atingiram. As três situações significam coisas diferentes: * **"Você atingiu seu limite de sessão" ou "Você atingiu seu limite semanal"**: uma janela de uso baseada em assento em um plano de assinatura. Essas janelas são compartilhadas em todos os modelos, então mudar de modelo com `/model` não restaura o acesso, embora mantenha o desenvolvedor trabalhando após a mensagem específica do modelo "Você atingiu seu limite de Opus". A mensagem mostra quando a janela é redefinida, e o desenvolvedor pode executar `/usage-credits` para solicitar uso além da cota se você tiver [créditos de uso](https://support.fuxi.com/en/articles/12429409-extra-usage-for-paid-fuxi-plans) ativados. Veja [erros de limite de uso](/pt/errors#youve-hit-your-session-limit). * **Um aviso de contexto ou auto-compact**: não é um limite de uso. A conversa cresceu perto do tamanho máximo de entrada do modelo, e Fuxi Code resume o histórico mais antigo para liberar espaço. Aponte o desenvolvedor para [reduzir uso de tokens](#reduce-token-usage). * **Gastos inesperadamente altos em um plano de API ou provedor de nuvem**: geralmente rastreia de volta para sessões longas que nunca foram limpas ou para Opus deixado como o modelo padrão. Os hábitos de maior impacto para compartilhar são limpar entre tarefas não relacionadas e corresponder o modelo ao trabalho, ambos cobertos em [reduzir uso de tokens](#reduce-token-usage).

Custos de tokens de equipes de agentes

[Equipes de agentes](/pt/agent-teams) geram múltiplas instâncias do Fuxi Code, cada uma com sua própria janela de contexto. O uso de tokens escala com o número de colegas de equipe ativos e quanto tempo cada um executa. Para manter os custos das equipes de agentes gerenciáveis: * Use Sonnet para colegas de equipe. Ele equilibra capacidade e custo para tarefas de coordenação. * Mantenha equipes pequenas. Cada colega de equipe executa sua própria janela de contexto, portanto, o uso de tokens é aproximadamente proporcional ao tamanho da equipe. * Mantenha prompts de geração focados. Colegas de equipe carregam FUXI.md, servidores MCP e skills automaticamente, mas tudo no prompt de geração adiciona ao seu contexto desde o início. * Desligue colegas de equipe quando o trabalho estiver concluído. Cada colega de equipe ativo continua consumindo tokens até sair ou a sessão terminar. * Equipes de agentes são desabilitadas por padrão. Defina `FUXI_CODE_EXPERIMENTAL_AGENT_TEAMS=1` em seu [settings.json](/pt/settings) ou ambiente para habilitá-las. Veja [habilitar equipes de agentes](/pt/agent-teams#enable-agent-teams).

Reduza o uso de tokens

Os custos de tokens escalam com o tamanho do contexto: quanto mais contexto Fuxi processa, mais tokens você usa. Fuxi Code otimiza automaticamente os custos através do [prompt caching](/pt/prompt-caching), que reduz custos para conteúdo repetido como prompts do sistema, e auto-compaction, que resume o histórico de conversa ao se aproximar dos limites de contexto. As seguintes estratégias ajudam você a manter o contexto pequeno e reduzir custos por mensagem.

Gerencie o contexto proativamente

Use `/usage` para verificar seu uso atual de tokens, ou [configure sua linha de status](/pt/statusline#context-window-usage) para exibi-la continuamente. * **Limpe entre tarefas**: Use `/clear` para começar do zero ao mudar para trabalho não relacionado. Contexto obsoleto desperdiça tokens em cada mensagem subsequente. Use `/rename` antes de limpar para que você possa encontrar facilmente a sessão depois, então `/resume` para retornar a ela. * **Adicione instruções de compactação personalizadas**: `/compact Focus on code samples and API usage` diz a Fuxi o que preservar durante a sumarização. Você também pode personalizar o comportamento de compactação em seu arquivo FUXI.md na raiz do seu projeto: ```markdown theme={null} # Compact instructions When you are using compact, please focus on test output and code changes ```

Escolha o modelo certo

Sonnet lida bem com a maioria das tarefas de codificação e custa menos que Opus. Reserve Opus para decisões arquitetônicas complexas ou raciocínio em múltiplas etapas. Use `/model` para alternar modelos no meio da sessão, ou defina um padrão em `/config`. Para tarefas simples de subagente, especifique `model: haiku` em sua [configuração de subagente](/pt/sub-agents#choose-a-model).

Reduza a sobrecarga do servidor MCP

As definições de ferramentas MCP são [adiadas por padrão](/pt/mcp#scale-with-mcp-tool-search), portanto apenas nomes de ferramentas entram no contexto até Fuxi usar uma ferramenta específica. Execute `/context` para ver o que está consumindo espaço. * **Prefira ferramentas CLI quando disponíveis**: Ferramentas como `gh`, `aws`, `gcloud` e `sentry-cli` são ainda mais eficientes em contexto do que servidores MCP porque não adicionam nenhuma listagem por ferramenta. Fuxi pode executar comandos CLI diretamente. * **Desabilite servidores não utilizados**: Execute `/mcp` para ver servidores configurados e desabilite qualquer um que você não esteja usando ativamente.

Instale plugins de inteligência de código para linguagens tipadas

[Plugins de inteligência de código](/pt/discover-plugins#code-intelligence) dão a Fuxi navegação de símbolo precisa em vez de busca baseada em texto, reduzindo leituras de arquivo desnecessárias ao explorar código desconhecido. Uma única chamada "ir para definição" substitui o que poderia ser um grep seguido de leitura de múltiplos arquivos candidatos. Servidores de linguagem instalados também relatam erros de tipo automaticamente após edições, portanto Fuxi detecta erros sem executar um compilador.

Descarregue o processamento para hooks e skills

[Hooks](/pt/hooks) personalizados podem pré-processar dados antes de Fuxi vê-los. Em vez de Fuxi ler um arquivo de log de 10.000 linhas para encontrar erros, um hook pode fazer grep para `ERROR` e retornar apenas linhas correspondentes, reduzindo contexto de dezenas de milhares de tokens para centenas. Uma [skill](/pt/skills) pode dar a Fuxi conhecimento de domínio para que não tenha que explorar. Por exemplo, uma skill "codebase-overview" poderia descrever a arquitetura do seu projeto, diretórios-chave e convenções de nomenclatura. Quando Fuxi invoca a skill, obtém este contexto imediatamente em vez de gastar tokens lendo múltiplos arquivos para entender a estrutura. Por exemplo, este hook PreToolUse filtra a saída de teste para mostrar apenas falhas: Adicione isto ao seu [settings.json](/pt/settings#settings-files) para executar o hook antes de cada comando Bash: ```json theme={null} { "hooks": { "PreToolUse": [ { "matcher": "Bash", "hooks": [ { "type": "command", "command": "~/.fuxi/hooks/filter-test-output.sh" } ] } ] } } ``` O hook chama este script. Crie a pasta com `mkdir -p ~/.fuxi/hooks`, salve o script abaixo como `~/.fuxi/hooks/filter-test-output.sh` e torne-o executável com `chmod +x ~/.fuxi/hooks/filter-test-output.sh`. Ele verifica se o comando é um executor de teste e o modifica para mostrar apenas falhas: ```bash theme={null} #!/bin/bash input=$(cat) cmd=$(echo "$input" | jq -r '.tool_input.command') # If running tests, filter to show only failures if [[ "$cmd" =~ ^(npm test|pytest|go test) ]]; then filtered_cmd="$cmd 2>&1 | grep -A 5 -E '(FAIL|ERROR|error:)' | head -100" echo "{\"hookSpecificOutput\":{\"hookEventName\":\"PreToolUse\",\"permissionDecision\":\"allow\",\"updatedInput\":{\"command\":\"$filtered_cmd\"}}}" else echo "{}" fi ```

Mova instruções de FUXI.md para skills

Seu arquivo [FUXI.md](/pt/memory) é carregado no contexto no início da sessão. Se contiver instruções detalhadas para fluxos de trabalho específicos (como revisões de PR ou migrações de banco de dados), esses tokens estão presentes mesmo quando você está fazendo trabalho não relacionado. [Skills](/pt/skills) carregam sob demanda apenas quando invocadas, portanto mover instruções especializadas para skills mantém seu contexto base menor. Procure manter FUXI.md com menos de 200 linhas incluindo apenas essenciais.

Ajuste o pensamento estendido

O pensamento estendido é habilitado por padrão porque melhora significativamente o desempenho em tarefas complexas de planejamento e raciocínio. Tokens de pensamento são faturados como tokens de saída, e o orçamento padrão pode ser dezenas de milhares de tokens por solicitação dependendo do modelo. Para tarefas mais simples onde raciocínio profundo não é necessário, você pode reduzir custos baixando o [nível de esforço](/pt/model-config#adjust-effort-level) com `/effort` ou em `/model`, desabilitando pensamento em `/config`, ou, em modelos com um [orçamento de pensamento fixo](/pt/model-config#adaptive-reasoning-and-fixed-thinking-budgets), baixando o orçamento definindo a [variável de ambiente](/pt/env-vars) `MAX_THINKING_TOKENS`, por exemplo `MAX_THINKING_TOKENS=8000`. Modelos de raciocínio adaptativo ignoram orçamentos diferentes de zero, portanto use níveis de esforço lá em vez disso. Desabilitar pensamento não está disponível no Fable 5, que sempre usa pensamento estendido.

Delegue operações verbosas para subagentes

Executar testes, buscar documentação ou processar arquivos de log pode consumir contexto significativo. Delegue estes para [subagentes](/pt/sub-agents#isolate-high-volume-operations) para que a saída verbosa permaneça no contexto do subagente enquanto apenas um resumo retorna à sua conversa principal.

Gerencie custos de equipes de agentes

Equipes de agentes usam aproximadamente 7x mais tokens do que sessões padrão quando colegas de equipe executam em modo de plano, porque cada colega de equipe mantém sua própria janela de contexto e executa como uma instância Fuxi separada. Mantenha tarefas de equipe pequenas e auto-contidas para limitar o uso de tokens por colega de equipe. Veja [equipes de agentes](/pt/agent-teams) para detalhes.

Escreva prompts específicos

Solicitações vagas como "melhorar esta base de código" disparam varredura ampla. Solicitações específicas como "adicionar validação de entrada à função de login em auth.ts" deixam Fuxi trabalhar eficientemente com leituras de arquivo mínimas.

Trabalhe eficientemente em tarefas complexas

Para trabalho mais longo ou complexo, esses hábitos ajudam a evitar tokens desperdiçados por seguir o caminho errado: * **Use modo de plano para tarefas complexas**: Pressione Shift+Tab para entrar em [modo de plano](/pt/permission-modes#analyze-before-you-edit-with-plan-mode) antes da implementação. Fuxi explora a base de código e propõe uma abordagem para sua aprovação, prevenindo retrabalho caro quando a direção inicial está errada. * **Corrija o curso cedo**: Se Fuxi começar a seguir a direção errada, pressione Escape para parar imediatamente. Use `/rewind` ou toque duplo em Escape para restaurar conversa e código para um checkpoint anterior. * **Dê alvos de verificação**: Inclua casos de teste, cole capturas de tela ou defina saída esperada em seu prompt. Quando Fuxi pode verificar seu próprio trabalho, detecta problemas antes de você precisar solicitar correções. * **Teste incrementalmente**: Escreva um arquivo, teste-o, depois continue. Isto detecta problemas cedo quando são baratos de corrigir.

Uso de tokens em segundo plano

Fuxi Code usa tokens para algumas funcionalidades em segundo plano mesmo quando ocioso: * **Sumarização de conversa**: Trabalhos em segundo plano que resumem conversas anteriores para o recurso `fuxi --resume` * **Processamento de comando**: Alguns comandos como `/usage` podem gerar solicitações para verificar status Esses processos em segundo plano consomem uma pequena quantidade de tokens (tipicamente menos de \$0.04 por sessão) mesmo sem interação ativa.

Entendendo mudanças no comportamento do Fuxi Code

Fuxi Code recebe regularmente atualizações que podem mudar como os recursos funcionam, incluindo relatório de custos. Execute `fuxi --version` para verificar sua versão atual. Para perguntas específicas de faturamento, entre em contato com o suporte da Anthropic através de sua [conta Console](https://platform.fuxi.com/login).