Utilisation de GitHub OAuth avec le Kit de développement logiciel (SDK) Copilot

Connectez les utilisateurs à GitHub Copilot en fournissant l’authentification de compte GitHub directement au sein de votre application.

          **Meilleur pour :** Applications multi-utilisateurs, outils internes avec contrôle d’accès de l’organisation, produits SaaS et applications où les utilisateurs ont GitHub déjà des comptes.

Fonctionnement

Vous créez une GitHub application OAuth (ou GitHub App), les utilisateurs l’autorisent et vous transmettez leur jeton d’accès au Kit de développement logiciel (SDK). Copilot les demandes sont effectuées au nom de chaque utilisateur authentifié, à l’aide de son Copilot abonnement. Pour obtenir des diagrammes de séquences détaillés de ce flux et de cette architecture, consultez le github/copilot-sdkréférentiel.

          **Principales caractéristiques :**

• Chaque utilisateur s’authentifie avec son propre GitHub compte.
• Copilot l’utilisation est facturée à l’abonnement de chaque utilisateur.
• Prend en charge GitHub les organisations et les comptes d’entreprise.
• Votre application ne gère jamais les clés API de modèle :GitHub gère tout.

Étape 1 : Créer une application OAuth GitHub

1. Accédez à GitHub Paramètres > Paramètres du développeur > applications OAuth > nouvelle application OAuth. Pour les organisations, accédez à Paramètres de l’organisation > Paramètres du développeur.
2. Remplissez les champs suivants :
   • Nom de l’application : nom de votre application.
   • URL de la page d’accueil : URL de votre application.
   • URL de rappel d’autorisation : votre point de terminaison de rappel OAuth (par exemple). https://YOUR-APP.com/auth/callback Remplacez YOUR-APP.com par votre domaine.
3. Notez votre ID client et générez une clé secrète client.

Étape 2 : Implémenter le flux OAuth

Votre application gère le flux OAuth standard GitHub . L’exemple suivant montre l’échange de jetons côté serveur :

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

Étape 3 : Passer le jeton au Kit de développement logiciel (SDK)

Créez un client sdk pour chaque utilisateur authentifié, en transmettant son jeton.

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

Remplacez USER-ACCESS-TOKEN par le jeton d’accès OAuth de l’utilisateur (par exemple, 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!"})

Allez

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

Accès des entreprises et des organisations

          GitHub OAuth prend naturellement en charge les scénarios d’entreprise. Lorsque les utilisateurs s’authentifient avec GitHub, leurs appartenances à l’organisation et les associations d’entreprise sont incluses.

Vérifier l’appartenance à l’organisation

Après OAuth, vous pouvez vérifier que l’utilisateur appartient à votre organisation :

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

Remplacez par YOUR-ORG le nom de votre GitHub organisation.

Utilisateurs gérés par l’entreprise (UEM)

Pour comptes d’utilisateur managés, le flux est identique. Les utilisateurs EMU s’authentifient via GitHub OAuth comme n'importe quel autre utilisateur, et les stratégies d’entreprise (restrictions IP, SSO SAML) sont appliquées GitHub automatiquement.

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

Types de jetons pris en charge

Préfixe de jeton	Origine	Soutenu
gho_	Jeton d’accès utilisateur OAuth	Oui
ghu_

          GitHub App jeton d’accès utilisateur | Oui |

| github_pat_ | Fine-grained personal access token | Oui | | ghp_ | Personal access token (classic) | Non (en cours de clôture) |

Gestion du cycle de vie des jetons

Votre application est responsable du stockage de jetons, de l’actualisation et de la gestion de l’expiration. Le Kit de développement logiciel (SDK) utilise le jeton que vous fournissez . Il ne gère pas le cycle de vie OAuth.

Modèle d’actualisation des jetons

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

Modèles multi-utilisateurs

Un client par utilisateur (recommandé)

Chaque utilisateur obtient son propre client sdk avec son propre jeton. Cela offre l’isolation la plus forte.

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

Limites

Limitation	Détails
**

          Copilot abonnement requis** | Chaque utilisateur a besoin d’un abonnement actif GitHub Copilot . |

| La gestion des jetons est votre responsabilité | Vous devez stocker, actualiser et gérer l’expiration du jeton. | | ** GitHub compte requis** | Les utilisateurs doivent avoir des GitHub comptes. | | Limites de débit par utilisateur | L’utilisation est soumise aux limites de taux de Copilot propres à chaque utilisateur. |

Étapes suivantes

• Pour exécuter le Kit de développement logiciel (SDK) sur des serveurs, consultez Configuration du Kit de développement logiciel (SDK) Copilot pour les services principaux.
• Pour gérer de nombreux utilisateurs simultanés, consultez Mise à l’échelle des déploiements du Kit de développement logiciel (SDK) Copilot.
• Pour l’installation et votre premier message, consultez Getting started avec le Kit de développement logiciel (SDK) Copilot.