{"meta":{"title":"Метрики использования и выставления счетов","intro":"В этом руководстве показано, как считывать счетчики маркеров, использование контекстного окна, стоимость кредита ИИ и квоту учетной записи из приложения пакета SDK для Copilot. Примеры показаны для TypeScript, Python, Go, .NET, Java и Rust.","product":"GitHub Copilot","breadcrumbs":[{"href":"/ru/copilot","title":"GitHub Copilot"},{"href":"/ru/copilot/how-tos","title":"Инструкции"},{"href":"/ru/copilot/how-tos/copilot-sdk","title":"Второй пилот SDK"},{"href":"/ru/copilot/how-tos/copilot-sdk/features","title":"Возможности"},{"href":"/ru/copilot/how-tos/copilot-sdk/features/usage-and-billing","title":"Использование и выставление счетов"}],"documentType":"article"},"body":"# Метрики использования и выставления счетов\n\nВ этом руководстве показано, как считывать счетчики маркеров, использование контекстного окна, стоимость кредита ИИ и квоту учетной записи из приложения пакета SDK для Copilot. Примеры показаны для TypeScript, Python, Go, .NET, Java и Rust.\n\n\n\n\n\n> \\[!TIP]\n> Каждый пример функционально эквивалентен для разных языков. Фрагмент кода TypeScript по умолчанию развернут; Выберите язык из свертых блоков, чтобы увидеть ту же логику в этом пакете SDK.\n\n## Overview\n\nПакет SDK предоставляет данные об использовании с помощью двух дополнительных механизмов:\n\n* **События сеанса**: временные события, которые среда выполнения выдает в качестве выполнения поворота. Подпишитесь на эти данные в режиме реального времени для каждого вызова API.\n* **Методы RPC: вызовы** запроса и ответа, которые вы выполняете по запросу. Используйте их для моментального снимка накопленных итогов или поиска квоты на уровне учетной записи.\n\nВ приведенной ниже таблице сопоставляется каждый сигнал с API, предоставляющим его.\n\n| Сигнал | API | Объем | Type |\n| ------------------------------------------------- | ------------------------------ | ------- | ----- |\n| Количество маркеров для каждого вызова | событие `assistant.usage` | Session | Event |\n| Использование контекстного окна | событие `session.usage_info` | Session | Event |\n| Разбивка контекстного окна (по запросу) | `session.metadata.contextInfo` | Session | RPC |\n| Совокупные суммы кредитов и маркеров ИИ | `session.usage.getMetrics` | Session | RPC |\n| Цены на кредиты на ИИ для модели | `models.list` | Сервер | RPC |\n| Квота учетной записи и взаимодействие с премиумом | `account.getQuota` | Сервер | RPC |\n\n> \\[!NOTE]\n> `session.usage.getMetrics`, `session.metadata.contextInfo`и `session.metadata.recomputeContextTokens` помечены экспериментальными в созданной поверхности RPC. В .NET они вызывают экспериментальную `GHCP001` диагностику, которая подавляется с помощью `#pragma warning disable GHCP001` или уровня `GHCP001`проекта. Закрепление пакета SDK и среды выполнения cli Copilot, если приложение зависит от них.\n\nВ приведенных ниже таблицах полей перечислены только поля, используемые в примерах на этой странице. Полный, всегда текущий справочник по полю — это созданные типы ПАКЕТА SDK, а также [События потоковых сессий](/ru/copilot/how-tos/copilot-sdk/features/streaming-events), который повторно создается из схемы CLI на каждом ударе зависимостей. Относиться к ним как к источнику истины и этой странице в качестве ориентированного на задачи руководства.\n\n## Количество маркеров для каждого вызова\n\nСобытие `assistant.usage` создается один раз для каждого вызова API модели в свою очередь (включая вызовы, сделанные вложенными агентами). Он содержит количество маркеров и умножение выставления счетов для этого одного вызова.\n\nВ приведенном ниже примере используются эти поля. Полный список см. в разделе [События потоковых сессий](/ru/copilot/how-tos/copilot-sdk/features/streaming-events#assistantusage) , включая кэш, причины, задержку и поля трассировки.\n\n| Поле | Type | Description |\n| -------------- | -------- | --------------------------------------------------------------- |\n| `model` | `string` | Идентификатор модели для этого вызова |\n| `inputTokens` | `number` | Расходуемые входные токены |\n| `outputTokens` | `number` | Выпускные токены |\n| `cost` | `number` | Умножение запросов уровня \"Премиум\", примененное к этому вызову |\n\n> \\[!TIP]\n> `assistant.usage` является эфемерным, поэтому он поставляется в реальном времени, но не воспроизводился при возобновлении сеанса. Чтобы прочитать накопленные итоговые итоги после факта, вызов `session.usage.getMetrics` (см. [сведения о накопленных кредитах и токенах ИИ](#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## Использование контекстного окна\n\nСчетчики маркеров сообщают, что каждый вызов использовался. Использование контекстного окна указывает, насколько полно окно запроса модели сейчас — полезно для отображения индикатора хода выполнения или предупреждения пользователя перед автоматическим сжатием.\n\n### Динамические обновления с помощью `session.usage_info`\n\nСреда выполнения выдает `session.usage_info` событие при изменении размера контекстного окна. Пример использования `currentTokens` и `tokenLimit`; см. в разделе [События потоковых сессий](/ru/copilot/how-tos/copilot-sdk/features/streaming-events#sessionusage_info) для полной полезных данных.\n\n| Поле | Type | Description |\n| --------------- | -------- | ------------------------------------------------------------ |\n| `currentTokens` | `number` | Маркеры в настоящее время в окне контекста |\n| `tokenLimit` | `number` | Максимальное количество токенов для контекстного окна модели |\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### Разбивка по запросу с `session.metadata.contextInfo`\n\nСобытия срабатывает только при изменении контекста. Чтобы прочитать текущую разбивку в любой момент( например, сразу после возобновления сеанса— вызов `session.metadata.contextInfo`. Передайте для `0` использования среды выполнения по умолчанию; передайте `promptTokenLimit``0` значение`outputTokenLimit`, если значение неизвестно.\n\n`contextInfo` Результат не `null` будет инициализирован до инициализации сеанса (системный запрос и метаданные инструмента были кэшированы). Он разбивает итог вниз `systemTokens`на , `conversationTokens`и `toolDefinitionsTokens`, наряду с `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## Совокупные суммы кредитов и маркеров ИИ\n\n`session.usage.getMetrics` возвращает итоги выполнения для всего сеанса в одном вызове. Это самый чистый способ чтения стоимости кредита ИИ, так как он агрегирует каждый вызов API (основной агент и вложенные агенты) для вас.\n\nВ примере используются приведенные ниже поля. Созданный `UsageGetMetricsResult` тип является полной ссылкой.\n\n| Поле | Type | Description |\n| ------------------------- | ----------------------------- | ------------------------------------------------------------------------------------------------- |\n| `totalNanoAiu` | `number` | Стоимость кредита на уровне сеанса ИИ в единицах nano-AI |\n| `totalPremiumRequestCost` | `number` | Стоимость запроса уровня \"Премиум\" во всех моделях после умножения |\n| `modelMetrics` | `Record` | Разбивка на модель; каждая запись имеет `usage.inputTokens`, `usage.outputTokens`и `totalNanoAiu` |\n\n> \\[!NOTE]\n> Стоимость сообщается в **единицах nano-AI** (это поле называется `totalNanoAiu`). Точное преобразование в кредиты ИИ и точное значение учета запросов уровня \"Премиум\" определяются GitHub Copilot выставлением счетов, а не пакетом SDK, рассматривать Copilot [документации](/ru/copilot/concepts/billing) по выставлению счетов GitHub как источник истины и проверить перед отображением валюты, например значений для пользователей. Примеры делятся на `1e9` удобство, следуя префиксу SI `nano` ; убедитесь, что это соответствует текущему выставлению счетов, прежде чем полагаться на него.\n> `modelMetrics` Карты `tokenDetails` ключом являются строки среды выполнения (идентификаторы модели и имена типов маркеров), которые система типов SDK не проверяет.\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## Цены на кредиты на ИИ для модели\n\nЧтобы оценить стоимость перед выполнением поворота, ознакомьтесь с ценами на маркеры каждой модели.`models.list` Это вызов на уровне сервера на клиенте, поэтому он не нуждается в сеансе. Цены выражаются в кредитах ИИ на пакет токенов выставления счетов. Созданный тип перечисляет каждое `ModelBillingTokenPrices` поле, в том числе `cachePrice`.\n\n| Поле | Type | Description |\n| --------------------------------- | -------- | --------------------------------------------------------- |\n| `billing.multiplier` | `number` | Умножение затрат на премиум по отношению к базовой ставке |\n| `billing.tokenPrices.inputPrice` | `number` | Затраты на кредит ИИ на пакет входных маркеров |\n| `billing.tokenPrices.outputPrice` | `number` | Затраты на кредит ИИ на пакет выходных маркеров |\n| `billing.tokenPrices.batchSize` | `number` | Количество маркеров на пакет выставления счетов |\n\n> \\[!NOTE]\n> Ценовые значения изменяются по мере развития планов и моделей. Прочитайте их во время выполнения, как показано ниже; никогда не жестко кодируйте числа в приложении.\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## Квота учетной записи и взаимодействие с премиумом\n\n`account.getQuota`сообщает о оставшейся Copilot права пользователя, прошедшего проверку подлинности. Карта результата `quotaSnapshots` определяется типом квоты, как правило `premium_interactions`, `chat`и `completions`. Используйте его, чтобы показать пользователям, сколько их ежемесячных пособий осталось, или ворот работы, прежде чем они достигли предела.\n\nВ примере используются приведенные ниже поля; Созданный `AccountQuotaSnapshot` тип является полной ссылкой. Ключи `quotaSnapshots` — это строки среды выполнения, которые система типов ПАКЕТА SDK не проверяет, поэтому защита подстановок.\n\n| Поле | Type | Description |\n| --------------------- | -------- | -------------------------------------------------------- |\n| `entitlementRequests` | `number` | Запросы, включенные в право, или `-1` для неограниченных |\n| `usedRequests` | `number` | Запросы, используемые до сих пор в этот период |\n| `remainingPercentage` | `number` | Процент оставшихся прав |\n| `resetDate` | `string` | Дата ISO 8601 при сбросе квоты |\n\n> \\[!TIP]\n> Чтобы считывать квоту для конкретного пользователя, а не глобального контекста проверки подлинности подключения (например, в серверной части с несколькими клиентами), передайте этот пользователь GitHub маркер`getQuota`. См [. раздел AUTOTITLE](/ru/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## Выбор правильного API\n\nИспользуйте эту сводку, чтобы решить, какой API соответствует вашему варианту использования:\n\n* **Отрисовка динамической стоимости или счетчика токенов в виде выполнения:** подписка на `assistant.usage` и `session.usage_info`.\n* **Отображение итоговой суммы затрат после поворота или сеанса**: вызов `session.usage.getMetrics`.\n* **Отображение использования контекстного окна при возобновлении перед любым новым поворотом**: вызов `session.metadata.contextInfo`.\n* **Оценка стоимости перед выполнением работы**: чтение `models.list` цен токенов.\n* **Предупреждайте пользователей, прежде чем они исчерпают свой план**: вызов `account.getQuota`.\n\n## Дополнительные материалы\n\n* [События потоковых сессий](/ru/copilot/how-tos/copilot-sdk/features/streaming-events): полный справочник по уровню поля для `assistant.usage`, `session.usage_info`и каждое другое событие сеанса\n* [Observability](/ru/copilot/how-tos/copilot-sdk/observability): экспорт данных об использовании в OpenTelemetry для присвоения затрат\n* [Мультиарендные и серверные развертывания](/ru/copilot/how-tos/copilot-sdk/setup/multi-tenancy): разрешение квоты и моделей на пользователя с помощью маркера GitHub"}