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.

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

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

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

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

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

import com.github.copilot.CopilotClient;
import com.github.copilot.rpc.*;

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 :

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

Étapes suivantes

• BYOK (apportez votre propre clé) : 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