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),
);
}
}
}
```
## Auslastung des Kontextfensters
Die Anzahl der Tokens zeigt Ihnen, wie viele Tokens jeder Aufruf verbraucht hat. Die Kontextfensternutzung teilt Ihnen mit, wie voll das Eingabeaufforderungsfenster des Modells momentan ist – nützlich für die Anzeige einer Statusleiste oder Warnung des Benutzers, bevor die automatische Komprimierung gestartet wird.
### Echtzeit-Updates mit `session.usage_info`
Die Laufzeit gibt ein `session.usage_info` Ereignis aus, wenn sich die Größe des Kontextfensters ändert. Das Beispiel verwendet `currentTokens` und `tokenLimit`; siehe [Ereignisse einer Streaming-Sitzung](/de/copilot/how-tos/copilot-sdk/features/streaming-events#sessionusage_info) für die vollständige Nutzlast.
| Feld | Typ | Description |
| --------------- | -------- | ------------------------------------------------- |
| `currentTokens` | `number` | Token derzeit im Kontextfenster |
| `tokenLimit` | `number` | Maximale Token für das Kontextfenster des Modells |
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);
}
}
}
```
### On-Demand-Aufschlüsselung mit `session.metadata.contextInfo`
Ereignisse werden nur ausgelöst, wenn sich der Kontext ändert. Um die aktuelle Aufschlüsselung jederzeit zu lesen , z. B. direkt nach dem Fortsetzen einer Sitzung – rufen Sie `session.metadata.contextInfo`auf. Übergeben Sie `promptTokenLimit` für `outputTokenLimit`, um den Standardwert der Laufzeit zu verwenden; übergeben Sie `0` für `0`, wenn der Wert unbekannt ist.
Das Ergebnis `contextInfo` ist `null` so lange, bis die Sitzung initialisiert wurde (die Systemaufforderung und die Toolmetadaten wurden zwischengespeichert). Es unterteilt die Gesamtsumme in `systemTokens`, `toolDefinitionsTokens` und `promptTokenLimit` sowie den `conversationTokens`.
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,
);
}
```
## Kumulierte KI-Guthaben- und Token-Gesamtsummen
`session.usage.getMetrics` gibt die laufenden Summen für die gesamte Sitzung in einem einzelnen Aufruf zurück. Dies ist die sauberste Möglichkeit, KI-Kreditkosten zu lesen, da sie jeden API-Aufruf (Haupt-Agent und Sub-Agents) für Sie aggregiert.
Im Beispiel werden die folgenden Felder verwendet. Der generierte `UsageGetMetricsResult` Typ ist der vollständige Verweis.
| Feld | Typ | Description |
| ------------------------- | ----------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `totalNanoAiu` | `number` | Sitzungsweite KI-Kreditkosten in Nano-AI-Einheiten |
| `totalPremiumRequestCost` | `number` | Premium-Anforderungskosten für alle Modelle, nach Multiplikatoren |
| `modelMetrics` | `Record