Verwenden von GitHub OAuth mit Copilot SDK

          Copilot SDK ist zurzeit in Technische Preview. Funktionalität und Verfügbarkeit können geändert werden.

Verbinden Sie Benutzer mit GitHub Copilot, indem Sie die GitHub Kontoauthentifizierung direkt in Ihrer Anwendung bereitstellen.

          **Am besten geeignet für:** Mehrbenutzer-Apps, interne Tools mit Organisationszugriffskontrolle, SaaS-Produkte und Apps, bei denen Benutzer bereits Über Konten verfügen GitHub .

So funktioniert es

Sie erstellen eine GitHub OAuth-App (oder GitHub App), Benutzer autorisieren sie, und Sie übergeben ihr Zugriffstoken an das SDK. Copilot Anforderungen werden im Namen jedes authentifizierten Benutzers unter Verwendung seines Copilot Abonnements gestellt. Detaillierte Sequenzdiagramme dieses Flusses und dieser Architektur finden Sie im github/copilot-sdkRepository.

          **Wichtige Merkmale:**

• Jeder Benutzer authentifiziert sich mit einem eigenen GitHub Konto.

•         Copilot Die Nutzung wird dem jeweiligen Abonnement in Rechnung gestellt.
  

• Unterstützt GitHub Organisationen und Unternehmenskonten.
• Ihre App verarbeitet niemals Modell-API-Schlüssel –GitHub verwaltet alles.

Schritt 1: Erstellen einer GitHub-OAuth-App

1. Wechseln Sie zu GitHub "Einstellungen" > "Entwicklereinstellungen", > OAuth-Apps > neue OAuth-App. Wechseln Sie für Organisationen zu den Organisationseinstellungen > Entwicklereinstellungen.
2. Füllen Sie die folgenden Felder aus: * Anwendungsname: Der Name Ihrer App. * Homepage-URL: Die URL Ihrer App. * Autorisierungsrückruf-URL: Ihr OAuth-Rückrufendpunkt (z. B https://YOUR-APP.com/auth/callback. ). Ersetzen Sie YOUR-APP.com durch Ihre Domäne.
3. Notieren Sie sich Ihre Client-ID , und generieren Sie einen geheimen Clientschlüssel.

Schritt 2: Implementieren des OAuth-Flusses

Ihre Anwendung behandelt den standardmäßigen GitHub OAuth-Fluss. Die folgende Abbildung zeigt den serverseitigen Tokenaustausch:

// Server-side: exchange authorization code for user token
async function handleOAuthCallback(code: string): Promise<string> {
    const response = await fetch("https://github.com/login/oauth/access_token", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            Accept: "application/json",
        },
        body: JSON.stringify({
            client_id: process.env.GITHUB_CLIENT_ID,
            client_secret: process.env.GITHUB_CLIENT_SECRET,
            code,
        }),
    });

    const data = await response.json();
    return data.access_token; // gho_xxxx or ghu_xxxx
}

Schritt 3: Übergeben des Tokens an das SDK

Erstellen Sie einen SDK-Client für jeden authentifizierten Benutzer, und übergeben Sie ihr Token.

Node.js / TypeScript

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

// Create a client for an authenticated user
function createClientForUser(userToken: string): CopilotClient {
    return new CopilotClient({
        githubToken: userToken,
        useLoggedInUser: false,  // Don't fall back to CLI sign-in
    });
}

// Usage
const client = createClientForUser("USER-ACCESS-TOKEN");
const session = await client.createSession({
    sessionId: `user-${userId}-session`,
    model: "gpt-4.1",
});

const response = await session.sendAndWait({ prompt: "Hello!" });

Ersetzen Sie USER-ACCESS-TOKEN durch das OAuth-Zugriffstoken des Benutzers (z. B. gho_xxxx).

Python

from copilot import CopilotClient, PermissionHandler

def create_client_for_user(user_token: str) -> CopilotClient:
    return CopilotClient({
        "github_token": user_token,
        "use_logged_in_user": False,
    })

# Usage
client = create_client_for_user("USER-ACCESS-TOKEN")
await client.start()

session = await client.create_session(
    on_permission_request=PermissionHandler.approve_all,
    model="gpt-4.1",
    session_id=f"user-{user_id}-session",
)

response = await session.send_and_wait({"prompt": "Hello!"})

Los geht's

func createClientForUser(userToken string) *copilot.Client {
    return copilot.NewClient(&copilot.ClientOptions{
        GithubToken:     userToken,
        UseLoggedInUser: copilot.Bool(false),
    })
}

// Usage
client := createClientForUser("USER-ACCESS-TOKEN")
client.Start(ctx)
defer client.Stop()

session, _ := client.CreateSession(ctx, &copilot.SessionConfig{
    SessionID: fmt.Sprintf("user-%s-session", userID),
    Model:     "gpt-4.1",
})
response, _ := session.SendAndWait(ctx, copilot.MessageOptions{Prompt: "Hello!"})

.NET

CopilotClient CreateClientForUser(string userToken) =>
    new CopilotClient(new CopilotClientOptions
    {
        GithubToken = userToken,
        UseLoggedInUser = false,
    });

// Usage
await using var client = CreateClientForUser("USER-ACCESS-TOKEN");
await using var session = await client.CreateSessionAsync(new SessionConfig
{
    SessionId = $"user-{userId}-session",
    Model = "gpt-4.1",
});

var response = await session.SendAndWaitAsync(
    new MessageOptions { Prompt = "Hello!" });

Unternehmens- und Organisationszugriff

          GitHub OAuth unterstützt natürlich Unternehmensszenarien. Wenn sich Benutzer bei GitHub authentifizieren, werden ihre Organisationsmitgliedschaften und Unternehmenszugehörigkeiten einbezogen.

Überprüfen der Organisationsmitgliedschaft

Nach OAuth können Sie überprüfen, ob der Benutzer zu Ihrer Organisation gehört:

async function verifyOrgMembership(
    token: string,
    requiredOrg: string
): Promise<boolean> {
    const response = await fetch("https://api.github.com/user/orgs", {
        headers: { Authorization: `Bearer ${token}` },
    });
    const orgs = await response.json();
    return orgs.some((org: any) => org.login === requiredOrg);
}

// In your auth flow
const token = await handleOAuthCallback(code);
if (!await verifyOrgMembership(token, "YOUR-ORG")) {
    throw new Error("User is not a member of the required organization");
}
const client = createClientForUser(token);

Ersetzen Sie YOUR-ORG durch den Namen Ihrer GitHub Organisation.

Von Unternehmen verwaltete Benutzer (EMU)

Für verwaltete Benutzerkonten, ist der Fluss identisch. EMU-Benutzer authentifizieren sich wie alle anderen Benutzer über GitHub OAuth, und die Unternehmensrichtlinien (IP-Einschränkungen, SAML SSO) werden von GitHub automatisch durchgesetzt.

// No special SDK configuration needed for EMU
const client = new CopilotClient({
    githubToken: emuUserToken,
    useLoggedInUser: false,
});

Unterstützte Tokentypen

Tokenpräfix	Quelle	Unterstützt
gho_	OAuth-Benutzerzugriffstoken	Ja
ghu_

          GitHub App Benutzerzugriffstoken | Ja |

| github_pat_ | Fine-grained personal access token | Ja | | ghp_ | Personal access token (classic) | Nein (schließen) |

Tokenlebenszyklusverwaltung

Ihre Anwendung ist für die Tokenspeicherung, Aktualisierung und Ablaufbehandlung verantwortlich. Das SDK verwendet das von Ihnen bereitgestellte Token – er verwaltet nicht den OAuth-Lebenszyklus.

Tokenaktualisierungsmuster

async function getOrRefreshToken(userId: string): Promise<string> {
    const stored = await tokenStore.get(userId);

    if (stored && !isExpired(stored)) {
        return stored.accessToken;
    }

    if (stored?.refreshToken) {
        const refreshed = await refreshGitHubToken(stored.refreshToken);
        await tokenStore.set(userId, refreshed);
        return refreshed.accessToken;
    }

    throw new Error("User must re-authenticate");
}

Mehrbenutzermuster

Ein Client pro Benutzer (empfohlen)

Jeder Benutzer erhält einen eigenen SDK-Client mit einem eigenen Token. Dies bietet die stärkste Isolation.

const clients = new Map<string, CopilotClient>();

function getClientForUser(userId: string, token: string): CopilotClient {
    if (!clients.has(userId)) {
        clients.set(userId, new CopilotClient({
            githubToken: token,
            useLoggedInUser: false,
        }));
    }
    return clients.get(userId)!;
}

Einschränkungen

Einschränkung	Einzelheiten

          **
          Copilot Abonnement erforderlich** | Jeder Benutzer benötigt ein aktives GitHub Copilot Abonnement. |

| Die Tokenverwaltung liegt in Ihrer Verantwortung | Sie müssen den Ablauf eines Tokens speichern, aktualisieren und verwalten. | | ** GitHub Konto erforderlich** | Benutzer müssen Über Konten verfügen GitHub . | | Ratenbeschränkungen pro Benutzer | Die Nutzung unterliegt den Grenzwerten Copilot der einzelnen Benutzerraten. |

Nächste Schritte

• Informationen zum Ausführen des SDK auf Servern finden Sie unter Einrichten des Copilot SDK für Back-End-Dienste.
• Informationen zum Behandeln vieler gleichzeitiger Benutzer finden Sie unter Skalieren von Copilot SDK-Bereitstellungen.
• Informationen zur Installation und ihrer ersten Nachricht finden Sie unter Erste Schritte mit dem Copilot SDK.