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`을 사용합니다. 전체 페이로드는 [스트리밍 세션 이벤트](/ko/copilot/how-tos/copilot-sdk/features/streaming-events#sessionusage_info)에서 확인하세요.
| Field | Type | 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`를 호출하세요.
`0` 런타임 기본값을 사용하도록 전달 `promptTokenLimit` 합니다. 값을 알 수 없는 경우 전달 `0``outputTokenLimit` 합니다.
결과는 `contextInfo``null` 세션이 초기화될 때까지입니다(시스템 프롬프트 및 도구 메타데이터가 캐시됨). 합계를 , , 및 로 나눕니다.
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` 는 단일 호출에서 전체 세션의 실행 합계를 반환합니다. 이는 모든 API 호출(주 에이전트 및 하위 에이전트)을 집계하기 때문에 AI 크레딧 비용을 읽는 가장 깨끗한 방법입니다.
이 예제에서는 아래 필드를 사용합니다. 생성된 `UsageGetMetricsResult` 형식이 전체 참조입니다.
| Field | Type | Description |
| ------------------------- | ----------------------------- | ------------------------------------------------------------------------ |
| `totalNanoAiu` | `number` | 세션 차원의 AI 크레딧 비용(nano-AI 단위) |
| `totalPremiumRequestCost` | `number` | 승수 적용 후 전체 모델에 걸친 프리미엄 요청 비용 |
| `modelMetrics` | `Record