TypeScript
```typescript
session.on("assistant.usage", (event) => {
const { model, inputTokens, outputTokens, cost } = event.data;
console.log(
`${model}: in=${inputTokens ?? 0} out=${outputTokens ?? 0} cost=${cost ?? 0}`,
);
});
```
Python
```python
def on_usage(event):
if event.type == SessionEventType.ASSISTANT_USAGE:
data = event.data
print(f"{data.model}: in={data.input_tokens or 0} out={data.output_tokens or 0} cost={data.cost or 0}")
session.on(on_usage)
```
Go
```golang
session.On(func(event copilot.SessionEvent) {
d, ok := event.Data.(*copilot.AssistantUsageData)
if !ok {
return
}
in, out, cost := int64(0), int64(0), float64(0)
if d.InputTokens != nil {
in = *d.InputTokens
}
if d.OutputTokens != nil {
out = *d.OutputTokens
}
if d.Cost != nil {
cost = *d.Cost
}
fmt.Printf("%s: in=%d out=%d cost=%g\n", d.Model, in, out, cost)
})
```
.NET
```csharp
session.On
(evt =>
{
var data = evt.Data;
Console.WriteLine(
$"{data.Model}: in={data.InputTokens ?? 0} out={data.OutputTokens ?? 0} cost={data.Cost ?? 0}");
});
```
Java
```java
session.on(AssistantUsageEvent.class, event -> {
var data = event.getData();
long in = data.inputTokens() != null ? data.inputTokens() : 0;
long out = data.outputTokens() != null ? data.outputTokens() : 0;
double cost = data.cost() != null ? data.cost() : 0.0;
System.out.printf("%s: in=%d out=%d cost=%s%n", data.model(), in, out, cost);
});
```
Rust
```rust
use github_copilot_sdk::session_events::AssistantUsageData;
let mut events = session.subscribe();
while let Ok(event) = events.recv().await {
if event.event_type == "assistant.usage" {
if let Some(data) = event.typed_data::
() {
println!(
"{}: in={} out={} cost={}",
data.model,
data.input_tokens.unwrap_or(0),
data.output_tokens.unwrap_or(0),
data.cost.unwrap_or(0.0),
);
}
}
}
```
## Utilização da janela de contexto
As 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.
### Atualizações em tempo real com `session.usage_info`
O 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.
| Campo | Tipo | Description |
| --------------- | -------- | -------------------------------------------------- |
| `currentTokens` | `number` | Tokens atualmente na janela de contexto |
| `tokenLimit` | `number` | Tokens máximos para a janela de contexto do modelo |
TypeScript
```typescript
session.on("session.usage_info", (event) => {
const { currentTokens, tokenLimit } = event.data;
const pct = Math.round((currentTokens / tokenLimit) * 100);
console.log(`Context: ${currentTokens}/${tokenLimit} (${pct}%)`);
});
```
Python
```python
def on_usage_info(event):
if event.type == SessionEventType.SESSION_USAGE_INFO:
data = event.data
pct = round(data.current_tokens / data.token_limit * 100)
print(f"Context: {data.current_tokens}/{data.token_limit} ({pct}%)")
session.on(on_usage_info)
```
Go
```golang
session.On(func(event copilot.SessionEvent) {
d, ok := event.Data.(*copilot.SessionUsageInfoData)
if !ok {
return
}
pct := int(float64(d.CurrentTokens) / float64(d.TokenLimit) * 100)
fmt.Printf("Context: %d/%d (%d%%)\n", d.CurrentTokens, d.TokenLimit, pct)
})
```
.NET
```csharp
session.On
(evt =>
{
var pct = (int)Math.Round((double)evt.Data.CurrentTokens / evt.Data.TokenLimit * 100);
Console.WriteLine($"Context: {evt.Data.CurrentTokens}/{evt.Data.TokenLimit} ({pct}%)");
});
```
Java
```java
session.on(SessionUsageInfoEvent.class, event -> {
var data = event.getData();
long pct = Math.round((double) data.currentTokens() / data.tokenLimit() * 100);
System.out.printf("Context: %d/%d (%d%%)%n", data.currentTokens(), data.tokenLimit(), pct);
});
```
Rust
```rust
use github_copilot_sdk::session_events::SessionUsageInfoData;
let mut events = session.subscribe();
while let Ok(event) = events.recv().await {
if event.event_type == "session.usage_info" {
if let Some(data) = event.typed_data::
() {
let pct = (data.current_tokens as f64 / data.token_limit as f64 * 100.0) as i64;
println!("Context: {}/{} ({}%)", data.current_tokens, data.token_limit, pct);
}
}
}
```
### Detalhamento sob demanda com `session.metadata.contextInfo`
Os 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.
O 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`.
TypeScript
```typescript
const { contextInfo } = await session.rpc.metadata.contextInfo({
promptTokenLimit: 0,
outputTokenLimit: 0,
});
if (contextInfo) {
console.log(
`Total ${contextInfo.totalTokens}/${contextInfo.promptTokenLimit} ` +
`(system=${contextInfo.systemTokens}, conversation=${contextInfo.conversationTokens})`,
);
}
```
Python
```python
result = await session.rpc.metadata.context_info(
MetadataContextInfoRequest(prompt_token_limit=0, output_token_limit=0)
)
info = result.context_info
if info is not None:
print(
f"Total {info.total_tokens}/{info.prompt_token_limit} "
f"(system={info.system_tokens}, conversation={info.conversation_tokens})"
)
```
Go
```golang
result, _ := session.RPC.Metadata.ContextInfo(ctx, &rpc.MetadataContextInfoRequest{
PromptTokenLimit: 0,
OutputTokenLimit: 0,
})
if info := result.ContextInfo; info != nil {
fmt.Printf("Total %d/%d (system=%d, conversation=%d)\n",
info.TotalTokens, info.PromptTokenLimit, info.SystemTokens, info.ConversationTokens)
}
```
.NET
```csharp
var result = await session.Rpc.Metadata.ContextInfoAsync(promptTokenLimit: 0, outputTokenLimit: 0);
var info = result.ContextInfo;
if (info is not null)
{
Console.WriteLine(
$"Total {info.TotalTokens}/{info.PromptTokenLimit} " +
$"(system={info.SystemTokens}, conversation={info.ConversationTokens})");
}
```
Java
```java
var result = session.getRpc().metadata
.contextInfo(new SessionMetadataContextInfoParams(null, 0L, 0L, null))
.join();
var info = result.contextInfo();
if (info != null) {
System.out.printf("Total %d/%d (system=%d, conversation=%d)%n",
info.totalTokens(), info.promptTokenLimit(), info.systemTokens(), info.conversationTokens());
}
```
Rust
```rust
use github_copilot_sdk::rpc::MetadataContextInfoRequest;
let result = session
.rpc()
.metadata()
.context_info(MetadataContextInfoRequest {
prompt_token_limit: 0,
output_token_limit: 0,
selected_model: None,
})
.await?;
if let Some(info) = result.context_info {
println!(
"Total {}/{} (system={}, conversation={})",
info.total_tokens, info.prompt_token_limit, info.system_tokens, info.conversation_tokens,
);
}
```
## Totais acumulados de créditos de IA e tokens
`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ê.
O exemplo usa os campos abaixo. O tipo gerado `UsageGetMetricsResult` é a referência completa.
| Campo | Tipo | Description |
| ------------------------- | ----------------------------- | --------------------------------------------------------------------------------------------------- |
| `totalNanoAiu` | `number` | Custo de crédito de IA em toda a sessão, em unidades de IA nano |
| `totalPremiumRequestCost` | `number` | Custo da solicitação premium entre todos os modelos, após a aplicação dos multiplicadores |
| `modelMetrics` | `Record