Nutzungs- und Abrechnungsmetriken

Tipp

Jedes Beispiel ist über die Sprachen hinweg funktional äquivalent. Der TypeScript-Codeausschnitt ist standardmäßig erweitert. Wählen Sie Ihre Sprache aus den reduzierbaren Blöcken aus, um die gleiche Logik in diesem SDK anzuzeigen.

Überblick

Das SDK zeigt Nutzungsdaten über zwei ergänzende Mechanismen an:

Sitzungsereignisse: kurzlebige Ereignisse, die von der Laufzeit während der Ausführung eines Turns ausgegeben werden. Abonnieren Sie diese, um Echtzeitdaten pro API-Aufruf zu erhalten.
RPC-Methoden: Anforderungs-/Antwortaufrufe, die Sie bei Bedarf tätigen. Verwenden Sie diese, um eine Momentaufnahme kumulierter Gesamtwerte zu erstellen oder das Kontingent auf Kontoebene abzufragen.

Die folgende Tabelle ordnet jedes Signal der API zu, die es verfügbar macht.

Signal	API	Geltungsbereich	Typ
Anzahl der Token pro Anruf
`assistant.usage`-Ereignis	Session	Event
Auslastung des Kontextfensters
`session.usage_info`-Ereignis	Session	Event
Aufschlüsselung des Kontextfensters (bei Bedarf)	`session.metadata.contextInfo`	Session	RPC
Kumulierte KI-Guthaben- und Token-Gesamtsummen	`session.usage.getMetrics`	Session	RPC
Preisgestaltung für KI-Credits pro Modell	`models.list`	Server	RPC
Kontokontingent- und Premiuminteraktionen	`account.getQuota`	Server	RPC

Hinweis

session.usage.getMetrics, session.metadata.contextInfound session.metadata.recomputeContextTokens sind in der generierten RPC-Oberfläche experimentell markiert. In .NET wird die experimentelle Diagnose GHCP001 ausgegeben, die Sie mit #pragma warning disable GHCP001 oder einer <NoWarn>GHCP001</NoWarn> auf Projektebene unterdrücken. Heften Sie sowohl das SDK als auch die Copilot-CLI-Laufzeitumgebung an, wenn Ihre Anwendung davon abhängt.

In den folgenden Feldtabellen sind nur die Felder aufgeführt, die in den Beispielen auf dieser Seite verwendet werden. Die vollständige, stets aktuelle Feldreferenz bilden die generierten SDK-Typen sowie Ereignisse einer Streaming-Sitzung, das bei jedem Abhängigkeitsbump aus dem CLI-Schema neu generiert wird. Betrachten Sie diese als die maßgebliche Quelle und diese Seite als einen aufgabenorientierten Leitfaden.

Anzahl der Token pro Anruf

Das assistant.usage Ereignis wird einmal für jeden Modell-API-Aufruf in einem Turn ausgegeben (einschließlich der von Unteragenten vorgenommenen Aufrufe). Es enthält die Tokenanzahl und den Abrechnungsmultiplikator für diesen einzelnen Anruf.

Im folgenden Beispiel werden diese Felder verwendet. Siehe Ereignisse einer Streaming-Sitzung für die vollständige Liste, einschließlich Feldern für Cache, Schlussfolgerung, Latenz und Nachverfolgung.

Feld	Typ	Description
`model`	`string`	Modellkennung für diesen Aufruf
`inputTokens`	`number`	Verbrauchte Eingabetoken
`outputTokens`	`number`	Erzeugte Ausgabetoken
`cost`	`number`	Premium-Anforderungsmultiplikator, der auf diesen Aufruf angewendet wurde

Tipp

assistant.usage ist flüchtig, wird also live bereitgestellt, aber beim Fortsetzen einer Sitzung nicht erneut abgespielt. Um kumulierte Gesamtwerte nachträglich auszulesen, rufen Sie session.usage.getMetrics auf (siehe Kumulierte KI-Gutschriften und Token-Gesamtwerte).

Codesprachen navigation

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

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)

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

session.On<AssistantUsageEvent>(evt =>
{
    var data = evt.Data;
    Console.WriteLine(
        $"{data.Model}: in={data.InputTokens ?? 0} out={data.OutputTokens ?? 0} cost={data.Cost ?? 0}");
});

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

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::<AssistantUsageData>() {
            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 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

Codesprachen navigation

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

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)

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

session.On<SessionUsageInfoEvent>(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

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

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::<SessionUsageInfoData>() {
            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.contextInfoauf. Ü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.

Codesprachen navigation

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

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})"
    )

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

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

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

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<string, ModelMetric>`	Modellbasierte Aufschlüsselung; jeder Eintrag hat `usage.inputTokens`, `usage.outputTokens`und `totalNanoAiu`

Hinweis

Die Kosten werden in Nano-AI-Einheiten gemeldet (das Feld ist benannt totalNanoAiu). Die genaue Konvertierung in KI-Gutschriften und die genaue Bedeutung der Premium-Anforderungsabrechnung werden durch GitHub Copilot Abrechnung definiert, nicht durch das SDK– behandeln Sie GitHub Copilot Abrechnungsdokumentation als Wahrheitsquelle und überprüfen Sie vor dem Auftauchen währungsähnlicher Werte für Benutzer. Die Beispiele teilen der Einfachheit halber durch 1e9, gemäß dem SI-Präfix nano. Vergewissern Sie sich, dass dies mit der aktuellen Abrechnung übereinstimmt, bevor Sie sich darauf verlassen. Die modelMetrics- und tokenDetails-Maps verwenden Laufzeitzeichenfolgen (Modell-IDs und Namen von Tokentypen) als Schlüssel, die vom SDK-Typsystem nicht validiert werden.

Codesprachen navigation

TypeScript

const metrics = await session.rpc.usage.getMetrics();

const aiCredits = (metrics.totalNanoAiu ?? 0) / 1e9;
console.log(`AI credits used: ${aiCredits.toFixed(6)}`);
console.log(`Premium requests: ${metrics.totalPremiumRequestCost}`);

for (const [model, m] of Object.entries(metrics.modelMetrics)) {
    if (!m) continue;
    console.log(
        `${model}: in=${m.usage.inputTokens} out=${m.usage.outputTokens} ` +
            `nanoAiu=${m.totalNanoAiu ?? 0}`,
    );
}

Python

metrics = await session.rpc.usage.get_metrics()

ai_credits = (metrics.total_nano_aiu or 0) / 1e9
print(f"AI credits used: {ai_credits:.6f}")
print(f"Premium requests: {metrics.total_premium_request_cost}")

for model, m in metrics.model_metrics.items():
    print(f"{model}: in={m.usage.input_tokens} out={m.usage.output_tokens} nanoAiu={m.total_nano_aiu or 0}")

metrics, _ := session.RPC.Usage.GetMetrics(ctx)

aiCredits := float64(0)
if metrics.TotalNanoAiu != nil {
    aiCredits = *metrics.TotalNanoAiu / 1e9
}
fmt.Printf("AI credits used: %.6f\n", aiCredits)
fmt.Printf("Premium requests: %v\n", metrics.TotalPremiumRequestCost)

for model, m := range metrics.ModelMetrics {
    nanoAiu := float64(0)
    if m.TotalNanoAiu != nil {
        nanoAiu = *m.TotalNanoAiu
    }
    fmt.Printf("%s: in=%d out=%d nanoAiu=%v\n", model, m.Usage.InputTokens, m.Usage.OutputTokens, nanoAiu)
}

.NET

var metrics = await session.Rpc.Usage.GetMetricsAsync();

var aiCredits = (metrics.TotalNanoAiu ?? 0) / 1e9;
Console.WriteLine($"AI credits used: {aiCredits:F6}");
Console.WriteLine($"Premium requests: {metrics.TotalPremiumRequestCost}");

foreach (var (model, m) in metrics.ModelMetrics)
{
    Console.WriteLine(
        $"{model}: in={m.Usage.InputTokens} out={m.Usage.OutputTokens} nanoAiu={m.TotalNanoAiu ?? 0}");
}

Java

var metrics = session.getRpc().usage.getMetrics().join();

double aiCredits = metrics.totalNanoAiu() != null ? metrics.totalNanoAiu() / 1e9 : 0;
System.out.printf("AI credits used: %.6f%n", aiCredits);
System.out.printf("Premium requests: %s%n", metrics.totalPremiumRequestCost());

metrics.modelMetrics().forEach((model, m) -> {
    double nanoAiu = m.totalNanoAiu() != null ? m.totalNanoAiu() : 0;
    System.out.printf("%s: in=%d out=%d nanoAiu=%s%n",
        model, m.usage().inputTokens(), m.usage().outputTokens(), nanoAiu);
});

Rust

let metrics = session.rpc().usage().get_metrics().await?;

let ai_credits = metrics.total_nano_aiu.unwrap_or(0.0) / 1e9;
println!("AI credits used: {ai_credits:.6}");
println!("Premium requests: {}", metrics.total_premium_request_cost);

for (model, m) in &metrics.model_metrics {
    let nano_aiu = m.total_nano_aiu.unwrap_or(0.0);
    println!(
        "{model}: in={} out={} nanoAiu={nano_aiu}",
        m.usage.input_tokens, m.usage.output_tokens,
    );
}

Preisgestaltung für KI-Credits pro Modell

Um die Kosten zu schätzen, bevor Sie einen Turn ausführen, lesen Sie die Tokenpreise jedes Modells von models.list. Dies ist ein serverbezogener Aufruf auf dem Client, sodass keine Sitzung erforderlich ist. Die Preise werden in KI-Gutschriften pro Abrechnungsbatch von Token ausgedrückt. Der generierte ModelBillingTokenPrices-Typ listet jedes Feld auf, einschließlich cachePrice.

Feld	Typ	Description
`billing.multiplier`	`number`	Kostenmultiplikator für Premium-Anforderungen relativ zum Basissatz
`billing.tokenPrices.inputPrice`	`number`	KI-Kreditkosten pro Batch von Eingabetoken
`billing.tokenPrices.outputPrice`	`number`	KI-Kreditkosten pro Batch von Ausgabetoken
`billing.tokenPrices.batchSize`	`number`	Anzahl der Token pro Abrechnungsbatch

Hinweis

Preiswerte ändern sich, wenn Pläne und Modelle weiterentwickelt werden. Lesen Sie sie zur Laufzeit wie unten gezeigt; codieren Sie die Zahlen niemals fest in Ihre Anwendung.

Codesprachen navigation

TypeScript

const { models } = await client.rpc.models.list({});

for (const model of models) {
    const prices = model.billing?.tokenPrices;
    if (!prices) continue;
    console.log(
        `${model.id}: input=${prices.inputPrice} output=${prices.outputPrice} ` +
            `per ${prices.batchSize} tokens (x${model.billing?.multiplier ?? 1})`,
    );
}

Python

result = await client.rpc.models.list(ModelsListRequest())

for model in result.models:
    prices = model.billing.token_prices if model.billing else None
    if prices is None:
        continue
    multiplier = model.billing.multiplier if model.billing else 1
    print(
        f"{model.id}: input={prices.input_price} output={prices.output_price} "
        f"per {prices.batch_size} tokens (x{multiplier})"
    )

list, _ := client.RPC.Models.List(ctx, &rpc.ModelsListRequest{})

for _, model := range list.Models {
    if model.Billing == nil || model.Billing.TokenPrices == nil {
        continue
    }
    prices := model.Billing.TokenPrices
    multiplier := 1.0
    if model.Billing.Multiplier != nil {
        multiplier = *model.Billing.Multiplier
    }
    in, out := 0.0, 0.0
    if prices.InputPrice != nil {
        in = *prices.InputPrice
    }
    if prices.OutputPrice != nil {
        out = *prices.OutputPrice
    }
    batch := int64(0)
    if prices.BatchSize != nil {
        batch = *prices.BatchSize
    }
    fmt.Printf("%s: input=%v output=%v per %d tokens (x%v)\n", model.ID, in, out, batch, multiplier)
}

.NET

var list = await client.Rpc.Models.ListAsync();

foreach (var model in list.Models)
{
    var prices = model.Billing?.TokenPrices;
    if (prices is null) continue;
    Console.WriteLine(
        $"{model.Id}: input={prices.InputPrice} output={prices.OutputPrice} " +
        $"per {prices.BatchSize} tokens (x{model.Billing?.Multiplier ?? 1})");
}

Java

var list = client.getRpc().models.list().join();

for (var model : list.models()) {
    var billing = model.billing();
    if (billing == null || billing.tokenPrices() == null) {
        continue;
    }
    var prices = billing.tokenPrices();
    double multiplier = billing.multiplier() != null ? billing.multiplier() : 1;
    System.out.printf("%s: input=%s output=%s per %d tokens (x%s)%n",
        model.id(), prices.inputPrice(), prices.outputPrice(), prices.batchSize(), multiplier);
}

Rust

let list = client.rpc().models().list().await?;

for model in &list.models {
    let Some(billing) = &model.billing else { continue };
    let Some(prices) = &billing.token_prices else { continue };
    let multiplier = billing.multiplier.unwrap_or(1.0);
    println!(
        "{}: input={} output={} per {} tokens (x{multiplier})",
        model.id,
        prices.input_price.unwrap_or(0.0),
        prices.output_price.unwrap_or(0.0),
        prices.batch_size.unwrap_or(0),
    );
}

Kontokontingent- und Premiuminteraktionen

account.getQuotameldet die verbleibende Copilot Berechtigung des authentifizierten Benutzers. Die quotaSnapshots-Zuordnung des Ergebnisses ist nach Kontingenttyp indiziert, üblicherweise premium_interactions, chat und completions. Verwenden Sie es, um Benutzern zu zeigen, wie viel von ihrem monatlichen Kontingent noch übrig ist, oder um Arbeit zu blockieren, bevor sie ein Limit erreichen.

Im Beispiel werden die folgenden Felder verwendet; Der generierte AccountQuotaSnapshot Typ ist der vollständige Verweis. Die quotaSnapshots-Schlüssel sind Zeichenfolgen zur Laufzeit, die vom SDK-Typsystem nicht überprüft werden. Sichern Sie Ihre Zugriffe daher entsprechend ab.

Feld	Typ	Description
`entitlementRequests`	`number`	Anforderungen, die in der Berechtigung enthalten sind, oder `-1` für unbegrenzt
`usedRequests`	`number`	Anforderungen, die bisher in diesem Zeitraum verwendet wurden
`remainingPercentage`	`number`	Prozentsatz der verbleibenden Berechtigung
`resetDate`	`string`	ISO 8601-Datum, an dem das Kontingent zurückgesetzt wird

Tipp

Um das Kontingent für einen bestimmten Benutzer anstelle des globalen Authentifizierungskontexts der Verbindung (z. B. in einem multimandantenbasierten Back-End) zu lesen, übergeben Sie das GitHub-Token dieses Benutzers an getQuota. Siehe Mandantenfähigkeit und Serverbereitstellungen.

Codesprachen navigation

TypeScript

const { quotaSnapshots } = await client.rpc.account.getQuota({});
const premium = quotaSnapshots["premium_interactions"];

if (premium) {
    console.log(
        `Premium interactions: ${premium.usedRequests}/${premium.entitlementRequests} ` +
            `(${premium.remainingPercentage.toFixed(1)}% left, resets ${premium.resetDate ?? "n/a"})`,
    );
}

Python

result = await client.rpc.account.get_quota(AccountGetQuotaRequest())
premium = result.quota_snapshots.get("premium_interactions")

if premium is not None:
    print(
        f"Premium interactions: {premium.used_requests}/{premium.entitlement_requests} "
        f"({premium.remaining_percentage:.1f}% left, resets {premium.reset_date or 'n/a'})"
    )

result, _ := client.RPC.Account.GetQuota(ctx, &rpc.AccountGetQuotaRequest{})

if premium, ok := result.QuotaSnapshots["premium_interactions"]; ok {
    resets := "n/a"
    if premium.ResetDate != nil {
        resets = premium.ResetDate.Format(time.RFC3339)
    }
    fmt.Printf("Premium interactions: %d/%d (%.1f%% left, resets %s)\n",
        premium.UsedRequests, premium.EntitlementRequests, premium.RemainingPercentage, resets)
}

.NET

var result = await client.Rpc.Account.GetQuotaAsync();

if (result.QuotaSnapshots.TryGetValue("premium_interactions", out var premium))
{
    Console.WriteLine(
        $"Premium interactions: {premium.UsedRequests}/{premium.EntitlementRequests} " +
        $"({premium.RemainingPercentage:F1}% left, resets {premium.ResetDate?.ToString("o") ?? "n/a"})");
}

Java

var result = client.getRpc().account.getQuota().join();
var premium = result.quotaSnapshots().get("premium_interactions");

if (premium != null) {
    System.out.printf("Premium interactions: %d/%d (%.1f%% left, resets %s)%n",
        premium.usedRequests(), premium.entitlementRequests(),
        premium.remainingPercentage(), premium.resetDate());
}

Rust

let result = client.rpc().account().get_quota().await?;

if let Some(premium) = result.quota_snapshots.get("premium_interactions") {
    let resets = premium.reset_date.as_deref().unwrap_or("n/a");
    println!(
        "Premium interactions: {}/{} ({:.1}% left, resets {resets})",
        premium.used_requests, premium.entitlement_requests, premium.remaining_percentage,
    );
}

Auswählen der richtigen API

Verwenden Sie diese Zusammenfassung, um zu entscheiden, welche API zu Ihrem Anwendungsfall passt:

Während der Ausführung eines Turns eine Live-Anzeige für Kosten oder Token anzeigen: Abonnieren Sie assistant.usage und session.usage_info.
Nach einem Turn oder einer Sitzung eine endgültige Kostenzusammenfassung anzeigen: Rufen Sie session.usage.getMetrics auf.
Beim Wiederaufnehmen die Nutzung des Kontextfensters anzeigen, bevor eine neuer Turn beginnt: Rufen Sie session.metadata.contextInfo auf.
Schätzen Sie die Kosten, bevor Sie die Aufgabe ausführen: Lesen Sie die models.list Tokenpreise.
Warnen Sie Benutzer, bevor sie ihren Plan erschöpfen: Anruf account.getQuota.

Weiterführende Lektüre

Ereignisse einer Streaming-Sitzung: vollständige Referenz auf Feldebene für assistant.usage, session.usage_infound jedes andere Sitzungsereignis
Beobachtbarkeit: Exportieren von Nutzungsdaten in OpenTelemetry zur Kostenzuordnung
Mandantenfähigkeit und Serverbereitstellungen: Auflösen des Kontingents pro Benutzer und Modelle mit einem GitHub-Token

In diesem Artikel

Codesprachen navigation

Codesprachen navigation

Codesprachen navigation

Codesprachen navigation

Codesprachen navigation

Codesprachen navigation