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),
);
}
}
}
```
## Uso de la ventana de contexto
Los recuentos de tokens te indican cuántos consumió cada llamada. El uso de la ventana de contexto indica cómo está completa la ventana de solicitud del modelo en este momento, útil para mostrar una barra de progreso o advertir al usuario antes de que se inicie la compactación automática.
### Actualizaciones en directo con `session.usage_info`
El entorno de ejecución emite el evento `session.usage_info` cada vez que cambia el tamaño de la ventana de contexto. En el ejemplo se usa `currentTokens` y `tokenLimit`; vea [Eventos de la sesión de transmisión](/es/copilot/how-tos/copilot-sdk/features/streaming-events#sessionusage_info) para obtener la carga completa.
| Campo | Tipo | Description |
| --------------- | -------- | -------------------------------------------------------------- |
| `currentTokens` | `number` | Tokens actualmente en la ventana de contexto |
| `tokenLimit` | `number` | Número máximo de tokens para la ventana de contexto del 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);
}
}
}
```
### Desglose a petición con `session.metadata.contextInfo`
Los eventos solo se activan cuando cambia el contexto. Para leer el desglose actual en cualquier momento (por ejemplo, justo después de reanudar una sesión), llame a `session.metadata.contextInfo`. Pase `0` para `promptTokenLimit` que use el valor predeterminado en tiempo de ejecución; pase `0` para `outputTokenLimit` si el valor es desconocido.
El resultado `contextInfo` es `null` hasta que se ha inicializado la sesión (se han almacenado en caché la solicitud del sistema y los metadatos de la herramienta). Divide el total en `systemTokens`, `conversationTokens`y `toolDefinitionsTokens`, junto con `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,
);
}
```
## Totales acumulados de créditos y tokens de IA
`session.usage.getMetrics` devuelve los totales acumulados de toda la sesión en una sola llamada. Esta es la forma más clara de consultar el coste de los créditos de IA, porque agrega por ti cada llamada a la API (agente principal y subagentes).
En el ejemplo se usan los campos siguientes. El tipo generado `UsageGetMetricsResult` es la referencia completa.
| Campo | Tipo | Description |
| ------------------------- | ----------------------------- | ------------------------------------------------------------------------------------------------- |
| `totalNanoAiu` | `number` | Coste de créditos de IA de toda la sesión, en unidades nano-IA |
| `totalPremiumRequestCost` | `number` | Coste de la solicitud prémium para todos los modelos, tras aplicar los multiplicadores |
| `modelMetrics` | `Record