Nutzungs- und Abrechnungsmetriken

Tipp

Jedes Beispiel ist funktional gleichbedeutend mit sprachenübergreifend. 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 die Laufzeit als Turnruns ausgibt. Abonnieren Sie diese für Echtzeit-, API-Aufrufdaten.
RPC-Methoden: Anforderungs-/Antwortaufrufe, die Sie bei Bedarf tätigen. Verwenden Sie diese, um gesammelte Summen zu snapshotn oder das Kontingent auf Kontoebene nachzuschlagen.

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
Kontextfensterverwendung
`session.usage_info`-Ereignis	Session	Event
Aufschlüsselung von Kontextfenstern (bei Bedarf)	`session.metadata.contextInfo`	Session	RPC
Akkumulierte KI-Gutschrift und Tokensummen	`session.usage.getMetrics`	Session	RPC
Ki-Kreditpreise 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 erhöhen sie die GHCP001 experimentelle Diagnose, die Sie mit #pragma warning disable GHCP001 oder auf Projektebene <NoWarn>GHCP001</NoWarn>unterdrücken. Pin both the SDK and the Copilot CLI runtime if your application depends on them.

In den folgenden Feldtabellen sind nur die Felder aufgeführt, die in den Beispielen auf dieser Seite verwendet werden. Der vollständige, immer aktuelle Feldverweis ist die generierten SDK-Typen plus Ereignisse einer Streaming-Sitzung, die aus dem CLI-Schema für jeden Abhängigkeitsstoß neu generiert wird. Behandeln Sie diese als Quelle der Wahrheit und dieser Seite als aufgabenorientierte Anleitung.

Anzahl der Token pro Anruf

Das assistant.usage Ereignis wird einmal für jeden Modell-API-Aufruf an einer Reihe ausgegeben (einschließlich Aufrufe von Unter-Agents). Es enthält die Tokenanzahl und den Abrechnungsmultiplikator für diesen einzelnen Anruf.

Im folgenden Beispiel werden diese Felder verwendet. Weitere Informationen finden Sie unter Ereignisse einer Streaming-Sitzung für die vollständige Liste, einschließlich Cache-, Reasoning-, Latenz- und Ablaufverfolgungsfeldern.

Feld	Typ	Description
`model`	`string`	Modellbezeichner 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 kurzlebig, sodass sie live übermittelt wird, aber nicht wiedergegeben wird, wenn Sie eine Sitzung fortsetzen. Rufen Sie an, session.usage.getMetrics um akkumulierte Summen nach der Tatsache zu lesen (siehe Akkumulierte KI-Gutschrift und Tokensummen).

Codesprachen navigation

TypeScript

import { CopilotClient } from "@github/copilot-sdk";

const client = new CopilotClient();
const session = await client.createSession({ streaming: true });

session.on("assistant.usage", (event) => {
    const { model, inputTokens, outputTokens, cost } = event.data;
    console.log(
        `${model}: in=${inputTokens ?? 0} out=${outputTokens ?? 0} cost=${cost ?? 0}`,
    );
});

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

from copilot import CopilotClient
from copilot.session_events import SessionEventType

client = CopilotClient()
session = await client.create_session(streaming=True)

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)

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)

package main

import (
    "context"
    "fmt"

    copilot "github.com/github/copilot-sdk/go"
    "github.com/github/copilot-sdk/go/rpc"
)

func main() {
    ctx := context.Background()
    client := copilot.NewClient(nil)
    client.Start(ctx)

    session, _ := client.CreateSession(ctx, &copilot.SessionConfig{
        Streaming: copilot.Bool(true),
        OnPermissionRequest: func(req copilot.PermissionRequest, inv copilot.PermissionInvocation) (rpc.PermissionDecision, error) {
            return &rpc.PermissionDecisionApproveOnce{}, nil
        },
    })

    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)
    })
    _ = session
}

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

using GitHub.Copilot;

await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(new SessionConfig { Streaming = true });

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

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),
            );
        }
    }
}

Kontextfensterverwendung

Tokenanzahl teilt Ihnen mit, was jeder Anruf 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.

Live-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 zurzeit im Kontextfenster
`tokenLimit`	`number`	Maximale Token für das Kontextfenster des Modells

Codesprachen navigation

TypeScript

import { CopilotClient } from "@github/copilot-sdk";

const client = new CopilotClient();
const session = await client.createSession({ streaming: true });

session.on("session.usage_info", (event) => {
    const { currentTokens, tokenLimit } = event.data;
    const pct = Math.round((currentTokens / tokenLimit) * 100);
    console.log(`Context: ${currentTokens}/${tokenLimit} (${pct}%)`);
});

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

from copilot import CopilotClient
from copilot.session_events import SessionEventType

client = CopilotClient()
session = await client.create_session(streaming=True)

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)

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)

package main

import (
    "context"
    "fmt"

    copilot "github.com/github/copilot-sdk/go"
    "github.com/github/copilot-sdk/go/rpc"
)

func main() {
    ctx := context.Background()
    client := copilot.NewClient(nil)
    client.Start(ctx)

    session, _ := client.CreateSession(ctx, &copilot.SessionConfig{
        Streaming: copilot.Bool(true),
        OnPermissionRequest: func(req copilot.PermissionRequest, inv copilot.PermissionInvocation) (rpc.PermissionDecision, error) {
            return &rpc.PermissionDecisionApproveOnce{}, nil
        },
    })

    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)
    })
    _ = session
}

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

using GitHub.Copilot;

await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(new SessionConfig { Streaming = true });

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

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 die Übergabe, promptTokenLimit um den Laufzeitstandard zu verwenden. Übergeben outputTokenLimit``0 Sie 0 den Wert, 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 bricht die Summe in systemTokens, , und toolDefinitionsTokens, neben den promptTokenLimit``conversationTokens.

Codesprachen navigation

TypeScript

import { CopilotClient } from "@github/copilot-sdk";

const client = new CopilotClient();
const session = await client.createSession({});

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})`,
    );
}

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

from copilot import CopilotClient
from copilot.rpc import MetadataContextInfoRequest

client = CopilotClient()
session = await client.create_session()

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

package main

import (
    "context"
    "fmt"

    copilot "github.com/github/copilot-sdk/go"
    "github.com/github/copilot-sdk/go/rpc"
)

func main() {
    ctx := context.Background()
    client := copilot.NewClient(nil)
    client.Start(ctx)

    session, _ := client.CreateSession(ctx, &copilot.SessionConfig{})

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

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

#pragma warning disable GHCP001
using GitHub.Copilot;

await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(new SessionConfig());

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})");
}
#pragma warning restore GHCP001

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,
    );
}

Akkumulierte KI-Gutschrift und Tokensummen

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 dividieren sich durch 1e9 eine Einfachheit nach dem SI-Präfix nano ; bestätigen Sie, dass dies der aktuellen Abrechnung entspricht, bevor Sie darauf vertrauen. Die modelMetrics Zuordnungen werden tokenDetails von Laufzeitzeichenfolgen (Modell-IDs und Tokentypnamen) schlüsselt, die vom SDK-Typsystem nicht überprüft werden.

Codesprachen navigation

TypeScript

import { CopilotClient } from "@github/copilot-sdk";

const client = new CopilotClient();
const session = await client.createSession({});

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}`,
    );
}

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

from copilot import CopilotClient

client = CopilotClient()
session = await client.create_session()

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

package main

import (
    "context"
    "fmt"

    copilot "github.com/github/copilot-sdk/go"
)

func main() {
    ctx := context.Background()
    client := copilot.NewClient(nil)
    client.Start(ctx)

    session, _ := client.CreateSession(ctx, &copilot.SessionConfig{})

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

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

#pragma warning disable GHCP001
using GitHub.Copilot;

await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(new SessionConfig());

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}");
}
#pragma warning restore GHCP001

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,
    );
}

Ki-Kreditpreise pro Modell

Um die Kosten zu schätzen, bevor Sie eine Drehung 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 Typ listet ModelBillingTokenPrices 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 dargestellt; Codieren Sie die Zahlen niemals hart in Ihre Anwendung.

Codesprachen navigation

TypeScript

import { CopilotClient } from "@github/copilot-sdk";

const client = new CopilotClient();

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})`,
    );
}

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

from copilot import CopilotClient
from copilot.rpc import ModelsListRequest

client = CopilotClient()

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

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

package main

import (
    "context"
    "fmt"

    copilot "github.com/github/copilot-sdk/go"
    "github.com/github/copilot-sdk/go/rpc"
)

func main() {
    ctx := context.Background()
    client := copilot.NewClient(nil)
    client.Start(ctx)

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

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

using GitHub.Copilot;

await using var client = new CopilotClient();

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

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 Zuordnung des Ergebnisses wird anhand des Kontingenttyps quotaSnapshots ( häufig premium_interactions, chat, und completions. Verwenden Sie es, um Benutzern zu zeigen, wie viel ihrer monatlichen Vergütung übrig bleibt, oder um zu toren, bevor sie einen Grenzwert erreichen.

Im Beispiel werden die folgenden Felder verwendet; Der generierte AccountQuotaSnapshot Typ ist der vollständige Verweis. Bei quotaSnapshots den Schlüsseln handelt es sich um Laufzeitzeichenfolgen, die vom SDK-Typsystem nicht überprüft werden, sodass Sie Ihre Nachschlagevorgänge schützen.

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

import { CopilotClient } from "@github/copilot-sdk";

const client = new CopilotClient();

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"})`,
    );
}

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

from copilot import CopilotClient
from copilot.rpc import AccountGetQuotaRequest

client = CopilotClient()

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

package main

import (
    "context"
    "fmt"
    "time"

    copilot "github.com/github/copilot-sdk/go"
    "github.com/github/copilot-sdk/go/rpc"
)

func main() {
    ctx := context.Background()
    client := copilot.NewClient(nil)
    client.Start(ctx)

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

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

using GitHub.Copilot;

await using var client = new CopilotClient();

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

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:

Rendern einer Live-Kosten- oder Tokenanzeige als Turn-Ausführung: abonnieren assistant.usage und session.usage_info.
Anzeigen einer endgültigen Kostenzusammenfassung nach einer Turn- oder Sitzung: Anruf session.usage.getMetrics.
Anzeigen der Kontextfensterverwendung beim Fortsetzen, bevor ein neuer Aufrufsession.metadata.contextInfo ausgeführt wird.
Schätzen Sie die Kosten vor der Ausführung der Arbeit: Lesen von models.list Tokenpreisen.
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