Configuración predeterminada (CLI agrupada)

Los SDK de Node.js, Python y .NET incluyen la CLI de Copilot como dependencia: la aplicación se distribuye con todo lo que necesita, sin necesidad de instalación ni configuración adicionales.

En este artículo

Lo mejor para: La mayoría de las aplicaciones: aplicaciones de escritorio, herramientas independientes, utilidades de la CLI, prototipos y mucho más.

Cómo funciona

Al instalar el SDK, el binario de la CLI de Copilot se incluye automáticamente. El SDK lo inicia como un proceso secundario y se comunica a través de stdio. No hay nada adicional para configurar.

Diagrama: Diagrama de flujo que muestra el proceso descrito.

Características principales:

  • El binario de la CLI se incluye con el SDK: no se necesita ninguna instalación independiente.
  • El SDK administra la versión de la CLI para garantizar la compatibilidad.
  • Los usuarios se autentican a través de la aplicación (o usan env vars/BYOK)
  • Las sesiones se administran por usuario en su máquina

Inicio rápido

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

Nota:

El SDK de Go no agrupa la CLI. Debe instalar la CLI por separado o establecer Connection para que apunte a un binario existente. Consulte Local CLI setup para obtener más información.

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

Nota:

El SDK de Java no agrupa ni inserta la CLI de Copilot. Debe instalar la CLI por separado y configurar su ruta de acceso mediante Connection o la variable de entorno 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();

Estrategias de autenticación

Debe decidir cómo se autenticarán los usuarios. Estos son los patrones comunes:

Diagrama: Diagrama de flujo que muestra el proceso descrito.

Opción A: credenciales de inicio de sesión del usuario (más sencilla)

El usuario inicia sesión en la CLI una vez y la aplicación usa esas credenciales. No se necesita código adicional: este es el comportamiento predeterminado.

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

Opción B: testigo mediante una variable de entorno

Envíe la aplicación con instrucciones para establecer un token o establecerla mediante programación:

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

Opción C: BYOK (sin autenticación GitHub necesaria)

Si gestionas tus propias claves de proveedor de modelos, los usuarios no necesitan cuentas de GitHub en absoluto:

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

Consulte BYOK (bring your own key) para obtener más información.

Administración de sesiones

Las aplicaciones suelen querer sesiones con nombre para que los usuarios puedan reanudar conversaciones:

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

El estado de sesión persiste en ~/.copilot/session-state/{sessionId}/.

Cuándo seguir adelante

RequisitoGuía siguiente
Usuarios que inician sesión con cuentas de GitHub
Configuración de OAuth de GitHub
Ejecución en un servidor en lugar de máquinas de usuario
Configuración de servicios back-end
Usa tus propias claves del modelo
BYOK (bring your own key)

Pasos siguientes