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),
);
}
}
}
```
## コンテキスト ウィンドウの使用率
トークン数は、各呼び出しで使用された内容を示します。 コンテキスト ウィンドウの使用率は、モデルのプロンプト ウィンドウが現在どの程度満たされているかを示します。これは、自動圧縮が開始される前に進行状況バーを表示したり、ユーザーに警告したりするのに役立ちます。
### `session.usage_info` によるリアルタイム更新
ランタイムは、コンテキスト ウィンドウのサイズが変更されるたびに、 `session.usage_info` イベントを生成します。 この例では、 `currentTokens` と `tokenLimit`を使用しています。完全なペイロードについては [ストリーミング セッション イベント](/ja/enterprise-cloud@latest/copilot/how-tos/copilot-sdk/features/streaming-events#sessionusage_info) を参照してください。
| フィールド | タイプ | Description |
| --------------- | -------- | ------------------------ |
| `currentTokens` | `number` | 現在コンテキスト ウィンドウ内のトークン |
| `tokenLimit` | `number` | モデルのコンテキスト ウィンドウの最大トークン数 |
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);
}
}
}
```
### `session.metadata.contextInfo` を使用したオンデマンドの内訳
イベントは、コンテキストが変更されたときにのみ発生します。 セッションの再開直後など、いつでも現在の内訳を読み取るために、 `session.metadata.contextInfo`を呼び出します。 ランタイムの既定値を使用する`promptTokenLimit`の`0`を渡します。値が不明な場合は、`outputTokenLimit`に`0`を渡します。
結果の `contextInfo` は、セッションが初期化されるまで `null` されます (システム プロンプトとツールメタデータがキャッシュされています)。 合計は、`promptTokenLimit`と共に`systemTokens`、`conversationTokens`、`toolDefinitionsTokens`に分割されます。
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,
);
}
```
## 累積 AI クレジットとトークンの合計
`session.usage.getMetrics` は、1 回の呼び出しでセッション全体の実行合計を返します。 これは、すべての API 呼び出し (メイン エージェントとサブエージェント) を集計するため、AI クレジット コストを読み取る最もクリーンな方法です。
この例では、次のフィールドを使用します。 生成された `UsageGetMetricsResult` 型は完全な参照です。
| フィールド | タイプ | Description |
| ------------------------- | ----------------------------- | ------------------------------------------------------------------------------ |
| `totalNanoAiu` | `number` | セッション全体の AI クレジット コスト (nano-AI ユニット単位) |
| `totalPremiumRequestCost` | `number` | すべてのモデルにおける、乗数適用後の Premium リクエスト コスト |
| `modelMetrics` | `Record