{"meta":{"title":"Métricas de uso e cobrança","intro":"Este guia mostra como ler a contagem de tokens, a utilização da janela de contexto, o custo em créditos de IA e a cota da conta em um aplicativo que usa o SDK do Copilot. Exemplos são mostrados para TypeScript, Python, Go, .NET, Java e Rust.","product":"GitHub Copilot","breadcrumbs":[{"href":"/pt/copilot","title":"GitHub Copilot"},{"href":"/pt/copilot/how-tos","title":"Instruções"},{"href":"/pt/copilot/how-tos/copilot-sdk","title":"SDK do Copilot"},{"href":"/pt/copilot/how-tos/copilot-sdk/features","title":"Features"},{"href":"/pt/copilot/how-tos/copilot-sdk/features/usage-and-billing","title":"Uso e cobrança"}],"documentType":"article"},"body":"# Métricas de uso e cobrança\n\nEste guia mostra como ler a contagem de tokens, a utilização da janela de contexto, o custo em créditos de IA e a cota da conta em um aplicativo que usa o SDK do Copilot. Exemplos são mostrados para TypeScript, Python, Go, .NET, Java e Rust.\n\n\n\n\n\n> \\[!TIP]\n> Cada exemplo é funcionalmente equivalente entre idiomas. O trecho de código em TypeScript é expandido por padrão; selecione seu idioma nos blocos expansíveis para ver a mesma lógica nesse SDK.\n\n## Visão Geral\n\nO SDK apresenta dados de uso por meio de dois mecanismos complementares:\n\n* **Eventos de sessão**: eventos efêmeros que o ambiente de execução emite durante a execução de um turno. Assine estes para obter dados em tempo real por chamada de API.\n* **Métodos RPC**: chamadas de solicitação/resposta feitas sob demanda. Use-os para registrar os totais acumulados ou consultar a cota da conta.\n\nA tabela abaixo mapeia cada sinal para a API que o expõe.\n\n| Sinal | API | Scope | Tipo |\n| ------------------------------------------------ | ------------------------------ | -------- | ---- |\n| Contagem de tokens por chamada | | | |\n| evento `assistant.usage` | Session | Event | |\n| Utilização da janela de contexto | | | |\n| evento `session.usage_info` | Session | Event | |\n| Detalhamento da janela de contexto (sob demanda) | `session.metadata.contextInfo` | Session | RPC |\n| Totais acumulados de créditos de IA e tokens | `session.usage.getMetrics` | Session | RPC |\n| Preços de crédito de IA por modelo | `models.list` | Servidor | RPC |\n| Quota da conta e interações premium | `account.getQuota` | Servidor | RPC |\n\n> \\[!NOTE]\n> `session.usage.getMetrics`, `session.metadata.contextInfo`e `session.metadata.recomputeContextTokens` são marcados como experimentais na superfície RPC gerada. Em .NET, é gerado o diagnóstico experimental `GHCP001`, que você suprime com `#pragma warning disable GHCP001` ou com uma `GHCP001` no nível do projeto. Fixe o SDK e o runtime da CLI do Copilot se o aplicativo depender deles.\n\nAs tabelas de campo abaixo listam apenas os campos usados nos exemplos nesta página. A referência completa e sempre atualizada dos campos consiste nos tipos gerados do SDK e em [Eventos de sessão de streaming](/pt/copilot/how-tos/copilot-sdk/features/streaming-events), que é regenerado a partir do esquema da CLI a cada atualização de dependência. Trate-os como a fonte da verdade e esta página como um guia orientado para tarefas.\n\n## Contagem de tokens por chamada\n\nO evento `assistant.usage` é emitido uma vez para cada chamada à API do modelo em uma rodada (incluindo chamadas feitas por sub-agentes). Ele inclui a contagem de tokens e o multiplicador de cobrança para essa chamada específica.\n\nO exemplo a seguir usa esses campos. Consulte [Eventos de sessão de streaming](/pt/copilot/how-tos/copilot-sdk/features/streaming-events#assistantusage) para obter a lista completa, incluindo cache, raciocínio, latência e campos de rastreamento.\n\n| Campo | Tipo | Description |\n| -------------- | -------- | ------------------------------------------------------------ |\n| `model` | `string` | Identificador de modelo para esta chamada |\n| `inputTokens` | `number` | Tokens de entrada consumidos |\n| `outputTokens` | `number` | Tokens de saída produzidos |\n| `cost` | `number` | Multiplicador de solicitação Premium aplicado a essa chamada |\n\n> \\[!TIP]\n> `assistant.usage` é efêmero, portanto é transmitido ao vivo, mas não é reproduzido ao retomar uma sessão. Para ler os totais acumulados posteriormente, chame `session.usage.getMetrics` (consulte [Totais acumulados de créditos de IA e tokens](#accumulated-ai-credit-and-token-totals)).\n\n
\n
TypeScript
\n\n```typescript\nsession.on(\"assistant.usage\", (event) => {\n const { model, inputTokens, outputTokens, cost } = event.data;\n console.log(\n `${model}: in=${inputTokens ?? 0} out=${outputTokens ?? 0} cost=${cost ?? 0}`,\n );\n});\n```\n\n
\n\n
Python
\n\n```python\ndef on_usage(event):\n if event.type == SessionEventType.ASSISTANT_USAGE:\n data = event.data\n print(f\"{data.model}: in={data.input_tokens or 0} out={data.output_tokens or 0} cost={data.cost or 0}\")\n\nsession.on(on_usage)\n```\n\n
\n\n
Go
\n\n```golang\nsession.On(func(event copilot.SessionEvent) {\n d, ok := event.Data.(*copilot.AssistantUsageData)\n if !ok {\n return\n }\n in, out, cost := int64(0), int64(0), float64(0)\n if d.InputTokens != nil {\n in = *d.InputTokens\n }\n if d.OutputTokens != nil {\n out = *d.OutputTokens\n }\n if d.Cost != nil {\n cost = *d.Cost\n }\n fmt.Printf(\"%s: in=%d out=%d cost=%g\\n\", d.Model, in, out, cost)\n})\n```\n\n
\n\n
.NET
\n\n```csharp\nsession.On(evt =>\n{\n var data = evt.Data;\n Console.WriteLine(\n $\"{data.Model}: in={data.InputTokens ?? 0} out={data.OutputTokens ?? 0} cost={data.Cost ?? 0}\");\n});\n```\n\n
\n\n
Java
\n\n\n\n```java\nsession.on(AssistantUsageEvent.class, event -> {\n var data = event.getData();\n long in = data.inputTokens() != null ? data.inputTokens() : 0;\n long out = data.outputTokens() != null ? data.outputTokens() : 0;\n double cost = data.cost() != null ? data.cost() : 0.0;\n System.out.printf(\"%s: in=%d out=%d cost=%s%n\", data.model(), in, out, cost);\n});\n```\n\n
\n\n
Rust
\n\n```rust\nuse github_copilot_sdk::session_events::AssistantUsageData;\n\nlet mut events = session.subscribe();\nwhile let Ok(event) = events.recv().await {\n if event.event_type == \"assistant.usage\" {\n if let Some(data) = event.typed_data::() {\n println!(\n \"{}: in={} out={} cost={}\",\n data.model,\n data.input_tokens.unwrap_or(0),\n data.output_tokens.unwrap_or(0),\n data.cost.unwrap_or(0.0),\n );\n }\n }\n}\n```\n\n
\n\n
\n\n## Utilização da janela de contexto\n\nAs contagens de tokens informam o que cada chamada consumiu. A utilização da janela de contexto indica o nível de ocupação da janela de contexto do modelo no momento, que é útil para exibir uma barra de progresso ou avisar o usuário antes que a compactação automática seja acionada.\n\n### Atualizações em tempo real com `session.usage_info`\n\nO runtime emite um `session.usage_info` evento sempre que o tamanho da janela de contexto é alterado. O exemplo usa `currentTokens` e `tokenLimit`; consulte [Eventos de sessão de streaming](/pt/copilot/how-tos/copilot-sdk/features/streaming-events#sessionusage_info) para a carga completa.\n\n| Campo | Tipo | Description |\n| --------------- | -------- | -------------------------------------------------- |\n| `currentTokens` | `number` | Tokens atualmente na janela de contexto |\n| `tokenLimit` | `number` | Tokens máximos para a janela de contexto do modelo |\n\n
\n
TypeScript
\n\n```typescript\nsession.on(\"session.usage_info\", (event) => {\n const { currentTokens, tokenLimit } = event.data;\n const pct = Math.round((currentTokens / tokenLimit) * 100);\n console.log(`Context: ${currentTokens}/${tokenLimit} (${pct}%)`);\n});\n```\n\n
\n\n
Python
\n\n```python\ndef on_usage_info(event):\n if event.type == SessionEventType.SESSION_USAGE_INFO:\n data = event.data\n pct = round(data.current_tokens / data.token_limit * 100)\n print(f\"Context: {data.current_tokens}/{data.token_limit} ({pct}%)\")\n\nsession.on(on_usage_info)\n```\n\n
\n\n
Go
\n\n```golang\nsession.On(func(event copilot.SessionEvent) {\n d, ok := event.Data.(*copilot.SessionUsageInfoData)\n if !ok {\n return\n }\n pct := int(float64(d.CurrentTokens) / float64(d.TokenLimit) * 100)\n fmt.Printf(\"Context: %d/%d (%d%%)\\n\", d.CurrentTokens, d.TokenLimit, pct)\n})\n```\n\n
\n\n
.NET
\n\n```csharp\nsession.On(evt =>\n{\n var pct = (int)Math.Round((double)evt.Data.CurrentTokens / evt.Data.TokenLimit * 100);\n Console.WriteLine($\"Context: {evt.Data.CurrentTokens}/{evt.Data.TokenLimit} ({pct}%)\");\n});\n```\n\n
\n\n
Java
\n\n\n\n```java\nsession.on(SessionUsageInfoEvent.class, event -> {\n var data = event.getData();\n long pct = Math.round((double) data.currentTokens() / data.tokenLimit() * 100);\n System.out.printf(\"Context: %d/%d (%d%%)%n\", data.currentTokens(), data.tokenLimit(), pct);\n});\n```\n\n
\n\n
Rust
\n\n```rust\nuse github_copilot_sdk::session_events::SessionUsageInfoData;\n\nlet mut events = session.subscribe();\nwhile let Ok(event) = events.recv().await {\n if event.event_type == \"session.usage_info\" {\n if let Some(data) = event.typed_data::() {\n let pct = (data.current_tokens as f64 / data.token_limit as f64 * 100.0) as i64;\n println!(\"Context: {}/{} ({}%)\", data.current_tokens, data.token_limit, pct);\n }\n }\n}\n```\n\n
\n\n
\n\n### Detalhamento sob demanda com `session.metadata.contextInfo`\n\nOs eventos só são acionados quando o contexto é alterado. Para ler o detalhamento atual a qualquer momento, por exemplo, logo após retomar uma sessão, use `session.metadata.contextInfo`. Passe `0` em `promptTokenLimit` para usar o padrão do tempo de execução; passe `0` em `outputTokenLimit` se o valor for desconhecido.\n\nO resultado `contextInfo` é `null` até que a sessão tenha sido inicializada (o prompt do sistema e os metadados de ferramenta foram armazenados em cache). Ele divide o total em `systemTokens`, `conversationTokens`e `toolDefinitionsTokens`, ao lado do `promptTokenLimit`.\n\n
\n
TypeScript
\n\n```typescript\nconst { contextInfo } = await session.rpc.metadata.contextInfo({\n promptTokenLimit: 0,\n outputTokenLimit: 0,\n});\n\nif (contextInfo) {\n console.log(\n `Total ${contextInfo.totalTokens}/${contextInfo.promptTokenLimit} ` +\n `(system=${contextInfo.systemTokens}, conversation=${contextInfo.conversationTokens})`,\n );\n}\n```\n\n
\n\n
Python
\n\n```python\nresult = await session.rpc.metadata.context_info(\n MetadataContextInfoRequest(prompt_token_limit=0, output_token_limit=0)\n)\ninfo = result.context_info\n\nif info is not None:\n print(\n f\"Total {info.total_tokens}/{info.prompt_token_limit} \"\n f\"(system={info.system_tokens}, conversation={info.conversation_tokens})\"\n )\n```\n\n
\n\n
Go
\n\n```golang\nresult, _ := session.RPC.Metadata.ContextInfo(ctx, &rpc.MetadataContextInfoRequest{\n PromptTokenLimit: 0,\n OutputTokenLimit: 0,\n})\n\nif info := result.ContextInfo; info != nil {\n fmt.Printf(\"Total %d/%d (system=%d, conversation=%d)\\n\",\n info.TotalTokens, info.PromptTokenLimit, info.SystemTokens, info.ConversationTokens)\n}\n```\n\n
\n\n
.NET
\n\n```csharp\nvar result = await session.Rpc.Metadata.ContextInfoAsync(promptTokenLimit: 0, outputTokenLimit: 0);\nvar info = result.ContextInfo;\n\nif (info is not null)\n{\n Console.WriteLine(\n $\"Total {info.TotalTokens}/{info.PromptTokenLimit} \" +\n $\"(system={info.SystemTokens}, conversation={info.ConversationTokens})\");\n}\n```\n\n
\n\n
Java
\n\n\n\n```java\nvar result = session.getRpc().metadata\n .contextInfo(new SessionMetadataContextInfoParams(null, 0L, 0L, null))\n .join();\nvar info = result.contextInfo();\n\nif (info != null) {\n System.out.printf(\"Total %d/%d (system=%d, conversation=%d)%n\",\n info.totalTokens(), info.promptTokenLimit(), info.systemTokens(), info.conversationTokens());\n}\n```\n\n
\n\n
Rust
\n\n```rust\nuse github_copilot_sdk::rpc::MetadataContextInfoRequest;\n\nlet result = session\n .rpc()\n .metadata()\n .context_info(MetadataContextInfoRequest {\n prompt_token_limit: 0,\n output_token_limit: 0,\n selected_model: None,\n })\n .await?;\n\nif let Some(info) = result.context_info {\n println!(\n \"Total {}/{} (system={}, conversation={})\",\n info.total_tokens, info.prompt_token_limit, info.system_tokens, info.conversation_tokens,\n );\n}\n```\n\n
\n\n
\n\n## Totais acumulados de créditos de IA e tokens\n\n`session.usage.getMetrics` retorna os totais acumulados de toda a sessão em uma única chamada. Essa é a maneira mais limpa de ler o custo de crédito de IA, pois agrega todas as chamadas à API (agente principal e subagentes) para você.\n\nO exemplo usa os campos abaixo. O tipo gerado `UsageGetMetricsResult` é a referência completa.\n\n| Campo | Tipo | Description |\n| ------------------------- | ----------------------------- | --------------------------------------------------------------------------------------------------- |\n| `totalNanoAiu` | `number` | Custo de crédito de IA em toda a sessão, em unidades de IA nano |\n| `totalPremiumRequestCost` | `number` | Custo da solicitação premium entre todos os modelos, após a aplicação dos multiplicadores |\n| `modelMetrics` | `Record` | Detalhamento por modelo; cada entrada tem `usage.inputTokens`, `usage.outputTokens`e `totalNanoAiu` |\n\n> \\[!NOTE]\n> O custo é relatado em **unidades nano-IA** (o campo é nomeado `totalNanoAiu`). A conversão exata em créditos de IA e o significado preciso da contabilização de solicitações premium são definidos pela cobrança do GitHub Copilot, não pelo SDK — trate [a documentação de cobrança do GitHub Copilot](/pt/copilot/concepts/billing) como fonte de referência e verifique isso antes de exibir valores monetários aos usuários. Os exemplos usam a divisão por `1e9` por conveniência, seguindo o prefixo `nano` do SI; confirme se isso corresponde à cobrança atual antes de confiar nisso. Os mapas `modelMetrics` e `tokenDetails` são indexados por strings de tempo de execução (IDs de modelo e nomes de tipos de token) que o sistema de tipos do SDK não valida.\n\n
\n
TypeScript
\n\n```typescript\nconst metrics = await session.rpc.usage.getMetrics();\n\nconst aiCredits = (metrics.totalNanoAiu ?? 0) / 1e9;\nconsole.log(`AI credits used: ${aiCredits.toFixed(6)}`);\nconsole.log(`Premium requests: ${metrics.totalPremiumRequestCost}`);\n\nfor (const [model, m] of Object.entries(metrics.modelMetrics)) {\n if (!m) continue;\n console.log(\n `${model}: in=${m.usage.inputTokens} out=${m.usage.outputTokens} ` +\n `nanoAiu=${m.totalNanoAiu ?? 0}`,\n );\n}\n```\n\n
\n\n
Python
\n\n```python\nmetrics = await session.rpc.usage.get_metrics()\n\nai_credits = (metrics.total_nano_aiu or 0) / 1e9\nprint(f\"AI credits used: {ai_credits:.6f}\")\nprint(f\"Premium requests: {metrics.total_premium_request_cost}\")\n\nfor model, m in metrics.model_metrics.items():\n print(f\"{model}: in={m.usage.input_tokens} out={m.usage.output_tokens} nanoAiu={m.total_nano_aiu or 0}\")\n```\n\n
\n\n
Go
\n\n```golang\nmetrics, _ := session.RPC.Usage.GetMetrics(ctx)\n\naiCredits := float64(0)\nif metrics.TotalNanoAiu != nil {\n aiCredits = *metrics.TotalNanoAiu / 1e9\n}\nfmt.Printf(\"AI credits used: %.6f\\n\", aiCredits)\nfmt.Printf(\"Premium requests: %v\\n\", metrics.TotalPremiumRequestCost)\n\nfor model, m := range metrics.ModelMetrics {\n nanoAiu := float64(0)\n if m.TotalNanoAiu != nil {\n nanoAiu = *m.TotalNanoAiu\n }\n fmt.Printf(\"%s: in=%d out=%d nanoAiu=%v\\n\", model, m.Usage.InputTokens, m.Usage.OutputTokens, nanoAiu)\n}\n```\n\n
\n\n
.NET
\n\n```csharp\nvar metrics = await session.Rpc.Usage.GetMetricsAsync();\n\nvar aiCredits = (metrics.TotalNanoAiu ?? 0) / 1e9;\nConsole.WriteLine($\"AI credits used: {aiCredits:F6}\");\nConsole.WriteLine($\"Premium requests: {metrics.TotalPremiumRequestCost}\");\n\nforeach (var (model, m) in metrics.ModelMetrics)\n{\n Console.WriteLine(\n $\"{model}: in={m.Usage.InputTokens} out={m.Usage.OutputTokens} nanoAiu={m.TotalNanoAiu ?? 0}\");\n}\n```\n\n
\n\n
Java
\n\n\n\n```java\nvar metrics = session.getRpc().usage.getMetrics().join();\n\ndouble aiCredits = metrics.totalNanoAiu() != null ? metrics.totalNanoAiu() / 1e9 : 0;\nSystem.out.printf(\"AI credits used: %.6f%n\", aiCredits);\nSystem.out.printf(\"Premium requests: %s%n\", metrics.totalPremiumRequestCost());\n\nmetrics.modelMetrics().forEach((model, m) -> {\n double nanoAiu = m.totalNanoAiu() != null ? m.totalNanoAiu() : 0;\n System.out.printf(\"%s: in=%d out=%d nanoAiu=%s%n\",\n model, m.usage().inputTokens(), m.usage().outputTokens(), nanoAiu);\n});\n```\n\n
\n\n
Rust
\n\n```rust\nlet metrics = session.rpc().usage().get_metrics().await?;\n\nlet ai_credits = metrics.total_nano_aiu.unwrap_or(0.0) / 1e9;\nprintln!(\"AI credits used: {ai_credits:.6}\");\nprintln!(\"Premium requests: {}\", metrics.total_premium_request_cost);\n\nfor (model, m) in &metrics.model_metrics {\n let nano_aiu = m.total_nano_aiu.unwrap_or(0.0);\n println!(\n \"{model}: in={} out={} nanoAiu={nano_aiu}\",\n m.usage.input_tokens, m.usage.output_tokens,\n );\n}\n```\n\n
\n\n
\n\n## Preços de crédito de IA por modelo\n\nPara estimar o custo antes de executar uma interação, leia os preços por token de cada modelo em `models.list`. Esta é uma chamada com escopo de servidor feita pelo cliente, portanto não requer sessão. Os preços são expressos em créditos de IA por lote de cobrança de tokens. O tipo gerado `ModelBillingTokenPrices` lista todos os campos, incluindo `cachePrice`.\n\n| Campo | Tipo | Description |\n| --------------------------------- | -------- | -------------------------------------------------------------------- |\n| `billing.multiplier` | `number` | Multiplicador de custo de solicitação Premium em relação à taxa base |\n| `billing.tokenPrices.inputPrice` | `number` | Custo de crédito de IA por lote de tokens de entrada |\n| `billing.tokenPrices.outputPrice` | `number` | Custo de créditos de IA por lote de tokens de saída |\n| `billing.tokenPrices.batchSize` | `number` | Número de tokens por lote de cobrança |\n\n> \\[!NOTE]\n> Os valores de preço mudam à medida que os planos e os modelos evoluem. Leia-os em tempo de execução, conforme mostrado abaixo; nunca codifique os números diretamente no seu aplicativo.\n\n
\n
TypeScript
\n\n```typescript\nconst { models } = await client.rpc.models.list({});\n\nfor (const model of models) {\n const prices = model.billing?.tokenPrices;\n if (!prices) continue;\n console.log(\n `${model.id}: input=${prices.inputPrice} output=${prices.outputPrice} ` +\n `per ${prices.batchSize} tokens (x${model.billing?.multiplier ?? 1})`,\n );\n}\n```\n\n
\n\n
Python
\n\n```python\nresult = await client.rpc.models.list(ModelsListRequest())\n\nfor model in result.models:\n prices = model.billing.token_prices if model.billing else None\n if prices is None:\n continue\n multiplier = model.billing.multiplier if model.billing else 1\n print(\n f\"{model.id}: input={prices.input_price} output={prices.output_price} \"\n f\"per {prices.batch_size} tokens (x{multiplier})\"\n )\n```\n\n
\n\n
Go
\n\n```golang\nlist, _ := client.RPC.Models.List(ctx, &rpc.ModelsListRequest{})\n\nfor _, model := range list.Models {\n if model.Billing == nil || model.Billing.TokenPrices == nil {\n continue\n }\n prices := model.Billing.TokenPrices\n multiplier := 1.0\n if model.Billing.Multiplier != nil {\n multiplier = *model.Billing.Multiplier\n }\n in, out := 0.0, 0.0\n if prices.InputPrice != nil {\n in = *prices.InputPrice\n }\n if prices.OutputPrice != nil {\n out = *prices.OutputPrice\n }\n batch := int64(0)\n if prices.BatchSize != nil {\n batch = *prices.BatchSize\n }\n fmt.Printf(\"%s: input=%v output=%v per %d tokens (x%v)\\n\", model.ID, in, out, batch, multiplier)\n}\n```\n\n
\n\n
.NET
\n\n```csharp\nvar list = await client.Rpc.Models.ListAsync();\n\nforeach (var model in list.Models)\n{\n var prices = model.Billing?.TokenPrices;\n if (prices is null) continue;\n Console.WriteLine(\n $\"{model.Id}: input={prices.InputPrice} output={prices.OutputPrice} \" +\n $\"per {prices.BatchSize} tokens (x{model.Billing?.Multiplier ?? 1})\");\n}\n```\n\n
\n\n
Java
\n\n\n\n```java\nvar list = client.getRpc().models.list().join();\n\nfor (var model : list.models()) {\n var billing = model.billing();\n if (billing == null || billing.tokenPrices() == null) {\n continue;\n }\n var prices = billing.tokenPrices();\n double multiplier = billing.multiplier() != null ? billing.multiplier() : 1;\n System.out.printf(\"%s: input=%s output=%s per %d tokens (x%s)%n\",\n model.id(), prices.inputPrice(), prices.outputPrice(), prices.batchSize(), multiplier);\n}\n```\n\n
\n\n
Rust
\n\n```rust\nlet list = client.rpc().models().list().await?;\n\nfor model in &list.models {\n let Some(billing) = &model.billing else { continue };\n let Some(prices) = &billing.token_prices else { continue };\n let multiplier = billing.multiplier.unwrap_or(1.0);\n println!(\n \"{}: input={} output={} per {} tokens (x{multiplier})\",\n model.id,\n prices.input_price.unwrap_or(0.0),\n prices.output_price.unwrap_or(0.0),\n prices.batch_size.unwrap_or(0),\n );\n}\n```\n\n
\n\n
\n\n## Quota da conta e interações premium\n\n`account.getQuota` informa a cota restante do Copilot do usuário autenticado. O mapa `quotaSnapshots` do resultado é chaveado por tipo de cota, geralmente `premium_interactions`, `chat`e `completions`. Use-o para mostrar aos usuários quanto resta da cota mensal deles ou para bloquear o trabalho antes que atinjam um limite.\n\nO exemplo usa os campos abaixo; o tipo gerado `AccountQuotaSnapshot` é a referência completa. As `quotaSnapshots` chaves são cadeias de caracteres de runtime que o sistema de tipo SDK não valida, portanto, proteja suas pesquisas.\n\n| Campo | Tipo | Description |\n| --------------------- | -------- | --------------------------------------------------------- |\n| `entitlementRequests` | `number` | Solicitações incluídas na franquia ou `-1` para ilimitado |\n| `usedRequests` | `number` | Solicitações usadas até agora neste período |\n| `remainingPercentage` | `number` | Porcentagem do direito restante |\n| `resetDate` | `string` | Data em formato ISO 8601 em que a cota é redefinida |\n\n> \\[!TIP]\n> Para ler a cota de um usuário específico em vez do contexto de autenticação global da conexão (por exemplo, em um back-end multilocatário), passe o token GitHub desse usuário para `getQuota`. Consulte [Multilocação e implantações de servidores](/pt/copilot/how-tos/copilot-sdk/setup/multi-tenancy).\n\n
\n
TypeScript
\n\n```typescript\nconst { quotaSnapshots } = await client.rpc.account.getQuota({});\nconst premium = quotaSnapshots[\"premium_interactions\"];\n\nif (premium) {\n console.log(\n `Premium interactions: ${premium.usedRequests}/${premium.entitlementRequests} ` +\n `(${premium.remainingPercentage.toFixed(1)}% left, resets ${premium.resetDate ?? \"n/a\"})`,\n );\n}\n```\n\n
\n\n
Python
\n\n```python\nresult = await client.rpc.account.get_quota(AccountGetQuotaRequest())\npremium = result.quota_snapshots.get(\"premium_interactions\")\n\nif premium is not None:\n print(\n f\"Premium interactions: {premium.used_requests}/{premium.entitlement_requests} \"\n f\"({premium.remaining_percentage:.1f}% left, resets {premium.reset_date or 'n/a'})\"\n )\n```\n\n
\n\n
Go
\n\n```golang\nresult, _ := client.RPC.Account.GetQuota(ctx, &rpc.AccountGetQuotaRequest{})\n\nif premium, ok := result.QuotaSnapshots[\"premium_interactions\"]; ok {\n resets := \"n/a\"\n if premium.ResetDate != nil {\n resets = premium.ResetDate.Format(time.RFC3339)\n }\n fmt.Printf(\"Premium interactions: %d/%d (%.1f%% left, resets %s)\\n\",\n premium.UsedRequests, premium.EntitlementRequests, premium.RemainingPercentage, resets)\n}\n```\n\n
\n\n
.NET
\n\n```csharp\nvar result = await client.Rpc.Account.GetQuotaAsync();\n\nif (result.QuotaSnapshots.TryGetValue(\"premium_interactions\", out var premium))\n{\n Console.WriteLine(\n $\"Premium interactions: {premium.UsedRequests}/{premium.EntitlementRequests} \" +\n $\"({premium.RemainingPercentage:F1}% left, resets {premium.ResetDate?.ToString(\"o\") ?? \"n/a\"})\");\n}\n```\n\n
\n\n
Java
\n\n\n\n```java\nvar result = client.getRpc().account.getQuota().join();\nvar premium = result.quotaSnapshots().get(\"premium_interactions\");\n\nif (premium != null) {\n System.out.printf(\"Premium interactions: %d/%d (%.1f%% left, resets %s)%n\",\n premium.usedRequests(), premium.entitlementRequests(),\n premium.remainingPercentage(), premium.resetDate());\n}\n```\n\n
\n\n
Rust
\n\n```rust\nlet result = client.rpc().account().get_quota().await?;\n\nif let Some(premium) = result.quota_snapshots.get(\"premium_interactions\") {\n let resets = premium.reset_date.as_deref().unwrap_or(\"n/a\");\n println!(\n \"Premium interactions: {}/{} ({:.1}% left, resets {resets})\",\n premium.used_requests, premium.entitlement_requests, premium.remaining_percentage,\n );\n}\n```\n\n
\n\n
\n\n## Escolhendo a API certa\n\nUse este resumo para decidir qual API se encaixa em seu caso de uso:\n\n* ```\n **Rederizar um medidor em tempo real de custo ou tokens à medida que uma interação é executada**: assine `assistant.usage` e `session.usage_info`.\n ```\n* ```\n **Mostrar um resumo final de custo após uma interação ou sessão**: chame `session.usage.getMetrics`.\n ```\n* ```\n **Exibir o uso da janela de contexto ao retomar, antes de qualquer nova interação**: chame `session.metadata.contextInfo`.\n ```\n* **Estimar o custo antes de executar o trabalho**: leia os `models.list` preços do token.\n* **Avisar os usuários antes que eles esgotem seu plano**: chamar `account.getQuota`.\n\n## Leitura adicional\n\n* [Eventos de sessão de streaming](/pt/copilot/how-tos/copilot-sdk/features/streaming-events): referência completa em nível de campo para `assistant.usage`, `session.usage_info` e todos os outros eventos da sessão\n* [Observability](/pt/copilot/how-tos/copilot-sdk/observability): exportar dados de uso para OpenTelemetry para atribuição de custo\n* [Multilocação e implantações de servidores](/pt/copilot/how-tos/copilot-sdk/setup/multi-tenancy): resolver a cota por usuário e modelos com um token GitHub"}