Configuration par défaut (interface CLI groupée)

Meilleur pour : La plupart des applications : applications de bureau, outils autonomes, utilitaires CLI, prototypes, etc.

Fonctionnement

Lorsque vous installez le Kit de développement logiciel (SDK), le fichier binaire cli Copilot est inclus automatiquement. Le kit de développement logiciel (SDK) le démarre comme processus enfant et communique via stdio. Il n’y a rien d’supplémentaire à configurer.

Diagramme : Organigramme montrant le processus décrit.

Principales caractéristiques :

Le fichier binaire CLI est inclus dans le Kit de développement logiciel (SDK) : aucune installation distincte n’est nécessaire
Le Kit de développement logiciel (SDK) gère la version cli pour garantir la compatibilité
Les utilisateurs s’authentifient via votre application (ou utilisent env vars / BYOK)
Les sessions sont gérées par utilisateur sur leur ordinateur

Démarrage rapide

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

Remarque

Le Kit de développement logiciel (SDK) Go ne regroupe pas l’interface CLI. Vous devez installer l’interface CLI séparément ou définir Connection pour qu’elle pointe vers un binaire existant. Pour plus d’informations, consultez Local CLI setup.

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

Remarque

Le sdk Java ne regroupe pas ni n’incorpore l’interface CLI Copilot. Vous devez installer l’interface CLI séparément et configurer son chemin via Connection ou la variable d’environnement COPILOT_CLI_PATH .

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

Stratégies d’authentification

Vous devez décider de la façon dont vos utilisateurs s’authentifient. Voici les modèles courants :

Diagramme : Organigramme montrant le processus décrit.

Option A : informations d’identification de l’utilisateur connecté (la plus simple)

L’utilisateur se connecte à l’interface CLI une seule fois, et votre application utilise ces informations d’identification. Aucun code supplémentaire n’est nécessaire : il s’agit du comportement par défaut.

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

Option B : jeton via une variable d’environnement

Envoyez votre application avec des instructions pour définir un jeton, ou définissez-la par programmation :

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

Option C : BYOK (aucune authentification GitHub nécessaire)

Si vous gérez vos propres clés de fournisseur de modèles, les utilisateurs n'ont pas besoin d'GitHub comptes du tout :

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

Pour plus d’informations, consultez autoTITLE .

Gestion des sessions

Les applications souhaitent généralement des sessions nommées afin que les utilisateurs puissent reprendre les conversations :

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

L’état de session persiste à l’adresse ~/.copilot/session-state/{sessionId}/.

Quand se déplacer

Besoin	Guide suivant
Utilisateurs se connectant avec des comptes GitHub
configuration de GitHub OAuth
Exécuter sur un serveur au lieu d’ordinateurs utilisateur
Configuration des services principaux
Utilisez vos propres clés de modèle
BYOK (bring your own key)

Étapes suivantes

BYOK (bring your own key) : Utilisez vos propres clés de fournisseur de modèles
Reprise de session et persistance : Gestion avancée des sessions
Créez votre première application avec Copilot : Créer une application complète

Configuration par défaut (interface CLI groupée)

Dans cet article