Standardsetup (gebündelte CLI)

Die Node.js, Python und .NET SDKs enthalten die Copilot CLI als Abhängigkeit – Ihre App enthält alles, was sie benötigt, ohne zusätzliche Installation oder Konfiguration erforderlich.

In diesem Artikel

Am besten geeignet für: Die meisten Anwendungen – Desktop-Apps, eigenständige Tools, CLI-Dienstprogramme, Prototypen und vieles mehr.

So funktioniert es

Wenn Sie das SDK installieren, wird die Copilot CLI-Binärdatei automatisch eingeschlossen. Das SDK startet es als untergeordneter Prozess und kommuniziert über Stdio. Es gibt nichts Zusätzliches zu konfigurieren.

Diagramm: Flussdiagramm mit dem beschriebenen Prozess.

Wichtige Merkmale:

  • CLI-Binärdatei ist im SDK enthalten – keine separate Installation erforderlich
  • Das SDK verwaltet die CLI-Version, um die Kompatibilität sicherzustellen.
  • Benutzer authentifizieren sich über Ihre App (oder verwenden Sie env vars / BYOK)
  • Sitzungen werden pro Benutzer auf ihrem Computer verwaltet.

Schnellstart

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

const client = new CopilotClient();

const session = await client.createSession({ model: "gpt-4.1" });
const response = await session.sendAndWait({ prompt: "Hello!" });
console.log(response?.data.content);

await client.stop();
Python
from copilot import CopilotClient
from copilot.session import PermissionHandler

client = CopilotClient()
await client.start()

session = await client.create_session(on_permission_request=PermissionHandler.approve_all, model="gpt-4.1")
response = await session.send_and_wait("Hello!")
print(response.data.content)

await client.stop()
Go

Hinweis

Das Go SDK bündelt die CLI nicht. Sie müssen die CLI separat installieren oder Connection so festlegen, dass es auf eine vorhandene Binärdatei verweist. Einzelheiten findest du unter Lokale CLI-Einrichtung.

package main

import (
    "context"
    "fmt"
    "log"
    copilot "github.com/github/copilot-sdk/go"
)

func main() {
    ctx := context.Background()

    client := copilot.NewClient(nil)
    if err := client.Start(ctx); err != nil {
        log.Fatal(err)
    }
    defer client.Stop()

    session, _ := client.CreateSession(ctx, &copilot.SessionConfig{Model: "gpt-4.1"})
    response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})
    if d, ok := response.Data.(*copilot.AssistantMessageData); ok {
        fmt.Println(d.Content)
    }
}

client := copilot.NewClient(nil)
if err := client.Start(ctx); err != nil {
    log.Fatal(err)
}
defer client.Stop()

session, _ := client.CreateSession(ctx, &copilot.SessionConfig{Model: "gpt-4.1"})
response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})
if d, ok := response.Data.(*copilot.AssistantMessageData); ok {
    fmt.Println(d.Content)
}
.NET
await using var client = new CopilotClient();
await using var session = await client.CreateSessionAsync(
    new SessionConfig { Model = "gpt-4.1" });

var response = await session.SendAndWaitAsync(
    new MessageOptions { Prompt = "Hello!" });
Console.WriteLine(response?.Data.Content);
Java

Hinweis

Das Java SDK bündelt oder bettet die Copilot CLI nicht ein. Sie müssen die CLI separat installieren und ihren Pfad über Connection oder die COPILOT_CLI_PATH Umgebungsvariable konfigurieren.

import com.github.copilot.sdk.CopilotClient;
import com.github.copilot.sdk.events.*;
import com.github.copilot.sdk.json.*;

var client = new CopilotClient(new CopilotClientOptions()
    // Point to the CLI binary installed on the system
    .setCliPath("/path/to/vendor/copilot")
);
client.start().get();

var session = client.createSession(new SessionConfig()
    .setModel("gpt-4.1")
    .setOnPermissionRequest(PermissionHandler.APPROVE_ALL)
).get();

var response = session.sendAndWait(new MessageOptions()
    .setPrompt("Hello!")).get();
System.out.println(response.getData().content());

client.stop().get();

Authentifizierungsstrategien

Sie müssen entscheiden, wie Sich Ihre Benutzer authentifizieren. Hier sind die allgemeinen Muster:

Diagramm: Flussdiagramm mit dem beschriebenen Prozess.

Option A: Anmeldeinformationen des Benutzers (am einfachsten)

Der Benutzer meldet sich einmal bei der CLI an, und Ihre App verwendet diese Anmeldeinformationen. Kein zusätzlicher Code erforderlich – dies ist das Standardverhalten.

const client = new CopilotClient();
// Default: uses signed-in user credentials

Option B: Token über Umgebungsvariable

Senden Sie Ihre App mit Anweisungen zum Festlegen eines Tokens, oder legen Sie sie programmgesteuert fest:

const client = new CopilotClient({
    env: {
        COPILOT_GITHUB_TOKEN: getUserToken(),  // Your app provides the token
    },
});

Option C: BYOK (keine GitHub Authentifizierung erforderlich)

Wenn Sie Ihre eigenen Modellanbieterschlüssel verwalten, benötigen Benutzer überhaupt keine GitHub Konten:

const client = new CopilotClient();

const session = await client.createSession({
    model: "gpt-4.1",
    provider: {
        type: "openai",
        baseUrl: "https://api.openai.com/v1",
        apiKey: process.env.OPENAI_API_KEY,
    },
});

Ausführliche Informationen finden Sie im BYOK (bring your own key) .

Sitzungsverwaltung

Apps möchten in der Regel benannte Sitzungen, damit Benutzer Unterhaltungen fortsetzen können:

const client = new CopilotClient();

// Create a session tied to the user's project
const sessionId = `project-${projectName}`;
const session = await client.createSession({
    sessionId,
    model: "gpt-4.1",
});

// User closes app...
// Later, resume where they left off
const resumed = await client.resumeSession(sessionId);

Der Sitzungszustand bleibt bei ~/.copilot/session-state/{sessionId}/.

Wann muss ich fortfahren?

BedarfNächster Leitfaden
Benutzer, die sich mit GitHub-Konten anmelden
Einrichtung von GitHub OAuth
Auf einem Server anstelle von Benutzercomputern ausführen
Einrichtung von Back-End-Diensten
Verwenden Sie Ihre eigenen Modellschlüssel
BYOK (bring your own key)

Nächste Schritte