Passer au contenu principal

​
Créer une première application Laravel compatible Copilot

Ce guide vous fait construire un assistant en ligne de commande avec Laravel Copilot SDK. Vous commencez par l’envoi d’un prompt unique, puis vous progressez vers les sessions, les événements et les outils.

​
Prérequis

Avant de commencer, vérifiez ce qui suit :
  • Le GitHub Copilot CLI est installé et authentifié
  • PHP 8.4+
  • Laravel 13.x
Vérifiez que le CLI est disponible : 
copilot --version

​
Installer le SDK

Installez le paquet via Composer : 
composer require revolution/laravel-copilot-sdk
Publiez la configuration si nécessaire : 
php artisan vendor:publish --tag=copilot-config
Si besoin, configurez le chemin du CLI dans .env : 
COPILOT_CLI_PATH=copilot

​
Envoyer un premier message

Créez une commande et appelez Copilot::run() : 
<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Revolution\Copilot\Facades\Copilot;

class CopilotDemo extends Command
{
    protected $signature = 'copilot:demo';
    protected $description = 'Demo Copilot SDK';

    public function handle()
    {
        $response = Copilot::run(prompt: 'What is 2 + 2?');

        $this->info($response->content());
    }
}
Exécutez la commande : 
php artisan copilot:demo

​
Maintenir le contexte grâce à une session

Pour utiliser plusieurs prompts dans une même conversation, utilisez Copilot::start() : 
use Revolution\Copilot\Contracts\CopilotSession;
use Revolution\Copilot\Facades\Copilot;

Copilot::start(function (CopilotSession $session) {
    $response = $session->sendAndWait(prompt: 'What is 2 + 2?');
    $this->info('Answer: '.$response->content());

    $response = $session->sendAndWait(prompt: 'Now multiply that by 3');
    $this->info('Answer: '.$response->content());
});

​
Traiter les événements de session

Enregistrez un gestionnaire d’événements via on() pour observer les messages de l’assistant et les échecs. 
use Revolution\Copilot\Contracts\CopilotSession;
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\SessionEvent;

Copilot::start(function (CopilotSession $session) {
    $session->on(function (SessionEvent $event): void {
        if ($event->isAssistantMessage()) {
            $this->info($event->content());
        } elseif ($event->failed()) {
            $this->error($event->errorMessage() ?? 'Unknown error');
        }
    });

    $session->sendAndWait(prompt: 'Tell me a short Laravel joke');
});

​
Ajouter un outil personnalisé

Définissez un outil avec un schéma JSON et un gestionnaire : 
use Illuminate\JsonSchema\JsonSchema;
use Revolution\Copilot\Contracts\CopilotSession;
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\SessionConfig;
use Revolution\Copilot\Types\Tool;

$parameters = JsonSchema::object([
    'topic' => JsonSchema::string()
        ->description('Topic to look up')
        ->required(),
])->toArray();

$config = new SessionConfig(
    tools: [
        Tool::define(
            name: 'lookup_fact',
            description: 'Returns a fact for a topic.',
            parameters: $parameters,
            handler: function (array $params): array {
                $topic = $params['topic'] ?? '';

                return [
                    'textResultForLlm' => "Fact for {$topic}",
                    'resultType' => 'success',
                    'sessionLog' => "lookup_fact: {$topic}",
                    'toolTelemetry' => [],
                ];
            },
        ),
    ],
);

Copilot::start(function (CopilotSession $session) {
    $response = $session->sendAndWait(
        prompt: 'Use lookup_fact to tell me something about Laravel.'
    );

    $this->info($response->content());
}, config: $config);

​
Construire un assistant interactif

En combinant sessions, événements et outils, vous pouvez construire une commande Artisan interactive. 
<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\JsonSchema\JsonSchema;
use Revolution\Copilot\Contracts\CopilotSession;
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\SessionConfig;
use Revolution\Copilot\Types\SessionEvent;
use Revolution\Copilot\Types\Tool;
use Revolution\Copilot\Types\ToolResultObject;

use function Laravel\Prompts\error;
use function Laravel\Prompts\info;
use function Laravel\Prompts\note;
use function Laravel\Prompts\spin;
use function Laravel\Prompts\text;

class CopilotAssistant extends Command
{
    protected $signature = 'copilot:assistant';
    protected $description = 'Interactive Copilot assistant';

    public function handle()
    {
        $facts = [
            'PHP' => 'A popular general-purpose scripting language for web development.',
            'Laravel' => 'A web application framework with expressive, elegant syntax.',
            'Composer' => 'Dependency manager for PHP.',
        ];

        $parameters = JsonSchema::object([
            'topic' => JsonSchema::string()
                ->description('Topic to look up')
                ->required(),
        ])->toArray();

        $config = new SessionConfig(
            tools: [
                Tool::define(
                    name: 'lookup_fact',
                    description: 'Returns a fun fact about a given topic.',
                    parameters: $parameters,
                    handler: function (array $params) use ($facts) {
                        $topic = $params['topic'] ?? '';
                        $fact = $facts[$topic] ?? "No fact available for {$topic}.";

                        return new ToolResultObject(
                            textResultForLlm: $fact,
                            resultType: 'success',
                            sessionLog: "lookup_fact: {$topic}",
                            toolTelemetry: [],
                        );
                    },
                ),
            ],
        );

        Copilot::start(function (CopilotSession $session) {
            info('Copilot assistant');
            info("Session: {$session->id()}");
            info("Try: Use lookup_fact to tell me about Laravel");

            $session->on(function (SessionEvent $event): void {
                if ($event->isAssistantMessage()) {
                    note($event->content());
                } elseif ($event->failed()) {
                    error($event->errorMessage() ?? 'Unknown error');
                }
            });

            while (true) {
                $prompt = text(
                    label: 'You',
                    placeholder: 'Ask me anything...',
                    required: true,
                    hint: 'Ctrl+C to exit',
                );

                spin(
                    callback: fn () => $session->sendAndWait($prompt),
                    message: 'Thinking...',
                );

                echo "\n";
            }
        }, config: $config);
    }
}
Exécutez la commande : 
php artisan copilot:assistant

​
Fonctionnement d’un outil

Lorsque vous définissez un outil, précisez trois choses :
  1. Ce que fait l’outil.
  2. Les paramètres qu’il reçoit.
  3. Le code du gestionnaire à exécuter.
Copilot décide s’il faut appeler l’outil selon l’entrée utilisateur, et le SDK exécute le gestionnaire puis renvoie le résultat.

​
Fonctionnalités à explorer ensuite

​
Connecter un serveur MCP

use Revolution\Copilot\Types\SessionConfig;

$config = new SessionConfig(
    mcpServers: [
        'github' => [
            'type' => 'http',
            'url' => 'https://api.githubcopilot.com/mcp/',
        ],
    ],
);

​
Créer un agent personnalisé

use Revolution\Copilot\Types\SessionConfig;

$config = new SessionConfig(
    customAgents: [
        [
            'name' => 'pr-reviewer',
            'displayName' => 'PR Reviewer',
            'description' => 'Reviews pull requests for best practices',
            'prompt' => 'You are an expert code reviewer. Focus on security, performance, and maintainability.',
        ],
    ],
);

​
Personnaliser le message système

use Revolution\Copilot\Types\SessionConfig;
use Revolution\Copilot\Types\SystemMessageConfig;

$config = new SessionConfig(
    systemMessage: new SystemMessageConfig(
        content: 'You are a helpful assistant for our engineering team. Always be concise.',
    ),
);

​
Se connecter à un serveur CLI externe

Démarrez le Copilot CLI en mode serveur : 
copilot --headless --port 4321
Ensuite, configurez l’URL de connexion dans .env : 
COPILOT_URL=tcp://127.0.0.1:4321
Lorsque COPILOT_URL est défini, le SDK ne lance pas un nouveau processus CLI et se connecte au serveur existant.

​
Télémétrie et observabilité

Configurez la télémétrie dans config/copilot.php : 
'telemetry' => [
    'otlpEndpoint' => 'http://localhost:4318',
],
Ou directement : 
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\TelemetryConfig;

Copilot::useStdio([
    'telemetry' => new TelemetryConfig(
        otlpEndpoint: 'http://localhost:4318',
    ),
]);

​
Aller plus loin

​
Étapes suivantes

Authentification

Choisissez la méthode d’authentification adaptée au local et au CI.

SessionConfig

Configurez le modèle, les hooks, les serveurs MCP et le comportement d’exécution.

SessionEvent

Comprenez les helpers d’événements spécifiques à Laravel et la gestion du cycle de vie.

Demandes de permission

Passez en revue le flux d’autorisation exigeant une approbation explicite pour exécuter des outils.

Outils

Invoquez le code de votre application depuis Copilot.

MCP

Branchez les outils prêts à l’emploi des serveurs MCP.
À ce stade, vous avez parcouru le flux central de Laravel Copilot SDK, depuis un prompt unique jusqu’à une session avec outils.
Références : Laravel Copilot SDK README, Laravel Copilot SDK Getting Started, GitHub Copilot SDK
Dernière modification le 13 juillet 2026

Sujets connexes

GitHub Copilot SDK pour LaravelGitHub Actions - GitHub Copilot SDK pour LaravelTests - GitHub Copilot SDK pour LaravelAuthentification - GitHub Copilot SDK pour LaravelLaravel Cloud - GitHub Copilot SDK pour Laravel